Emacs on Emacs@ Dyerdwelling

Ollama Buddy - Web Search Integration

James Dyer — Wed, 04 Mar 2026 09:34:00 +0000

One of the fundamental limitations of local LLMs is their knowledge cutoff - they don’t know about anything that happened after their training data ended. The new web search integration in ollama-buddy solves this by fetching current information from the web and injecting it into your conversation context. Ollama has a specific API web search section, so it has now been activated!

Here is a demonstration:

https://www.youtube.com/watch?v=05VzAajH404

The web search feature implements a multi-stage pipeline that transforms search queries into clean, LLM-friendly context, your search query is sent to Ollama’s Web Search API, the API returns structured search results with URLs and snippets.

I have decided that each URL by default is fetched and processed through Emacs’ built-in eww and shr HTML rendering, but this can of course be configured, set ollama-buddy-web-search-content-source to control how content is retrieved:

`eww’ (default): Fetch each URL and render through eww/shr for clean text
`api’: Use content returned directly from Ollama API (faster, less refined)

The shr (Simple HTML Renderer) library does an excellent job of converting HTML to readable plain text, stripping ads, navigation, and other noise, so I thought why not just use this rather than the return results from the ollama API, as they didn’t seem to be particularly accurate.

The cleaned text is formatted with org headings showing the source URL and attached to your conversation context, so when you send your next prompt, the search results are automatically included in the context. The LLM can now reason about current information as if it had this knowledge all along.

There are multiple ways to search; firstly, is inline @search() syntax in your prompts (gradually expanding the inline prompting language!), so for example:

What are the key improvements in @search(Emacs 31 new features)?
Compare @search(Rust async programming) with @search(Go concurrency model)

ollama-buddy automatically detects these markers, executes the searches, attaches the results, and then sends your prompt, so you can carry out multiple searches.

You can also manual Search and Attach, Use C-c / a (or M-x ollama-buddy-web-search-attach)

The search executes, results are attached to your session, and the ♁1 indicator appears in the header line and the results can be viewed from the attachments menu, so for example would display something like:

* Web Searches (1)
** latest Emacs 31 features
*** 1. Hide Minor Modes in the Modeline in Emacs 31
*** 2. New Window Commands For Emacs 31
*** 3. Latest version of Emacs (GNU Emacs FAQ)
*** 4. bug#74145: 31.0.50; Default lexical-binding to t
*** 5. New in Emacs 30 (GNU Emacs FAQ)

with each header foldable, containing the actual search results.

There is a little configuration required to go through the ollama API, first, get an API key from https://ollama.com/settings/keys (it’s free). Then configure:

(use-package ollama-buddy
 :bind
 ("C-c o" . ollama-buddy-role-transient-menu)
 ("C-c O" . ollama-buddy-transient-menu-wrapper)
 :custom
 ;; Required: Your Ollama web search API key
 (ollama-buddy-web-search-api-key "your-api-key-here"))

For clarification, the content source options are as follows:

The ollama-buddy-web-search-content-source variable controls how content is retrieved:

eww (default, recommended)

Fetches each URL and renders HTML through Emacs’ eww/shr. Produces cleaner, more complete content but requires additional HTTP requests.

Pros:

Much cleaner text extraction
Full page content, not just snippets
Removes ads, navigation, clutter
Works with any website

Cons:

Slightly slower (additional HTTP requests)
Requires network access for each URL

api (experimental)

Uses content returned directly from the Ollama API without fetching individual URLs. Faster but content quality depends on what the API provides.

Pros:

Faster (single API call)
Less network traffic

Cons:

Content may be truncated
Quality varies by source
May miss important context

I strongly recommend sticking with eww - the quality difference is substantial.

By default, web search fetches up to 5 URLs with 2000 characters per result. This provides rich context without overwhelming the LLM’s context window.

For longer research sessions, you can adjust:

(setq ollama-buddy-web-search-max-results 10) ;; More sources
(setq ollama-buddy-web-search-snippet-length 5000) ;; Longer excerpts

Be mindful of your LLM’s context window limits. With 5 results at 2000 chars each, you’re adding ~10K characters to your context.

The web search integration fundamentally expands what your local LLMs can do. They’re no longer limited to their training data - they can reach out, fetch current information, and reason about it just like they would with any other context, so hopefully this will now make ollama-buddy a little more useful

Ollama Buddy v2.5 - RAG (Retrieval-Augmented Generation) Support

James Dyer — Tue, 24 Feb 2026 11:50:00 +0000

One of the things that has always slightly bothered me about chatting with a local LLM is that it only knows what it was trained on (although I suppose most LLMs are like that) . Ask it about your own codebase, your org notes, your project docs - and it’s just guessing. Well, not anymore! Ollama Buddy now ships with proper Retrieval Augmented Generation support built-in

What even is RAG?

If you haven’t come across the term before, the basic idea is simple. Instead of asking the LLM a question cold, you first go off and find the most relevant bits of text from your own documents, then you hand those bits to the LLM along with your question. The LLM now has actual context to work with rather than just vibes. The “retrieval” part is done using vector embeddings - each chunk of your documents gets turned into a mathematical representation, and at query time your question gets the same treatment. Chunks that are mathematically “close” to your question are the ones that get retrieved.

In this case, I have worked to keep the whole pipeline inside Emacs; it talks to Ollama directly to contact an embedding model, which then returns the required information. I have tried to make this as Emacs Org-friendly as possible by storing the embedding information in Org files.

Getting started

You’ll need an embedding model pulled alongside your chat model. The default is nomic-embed-text which is a solid general-purpose choice:

ollama pull nomic-embed-text

or just do it within ollama-buddy from the Model Management page.

Indexing your documents

The main entry point is M-x ollama-buddy-rag-index-directory. Point it at a directory and it will crawl through, chunk everything up, generate embeddings for each chunk, and save an index file. The first time you run this it can take a while depending on how much content you have and how fast your machine is - subsequent updates are much quicker as it only processes changed files.

Supported file types (and I even managed to get pdf text extraction working!):

Emacs Lisp (.el)
Python, JavaScript, TypeScript, Go, Rust, C/C++, Java, Ruby - basically most languages
Org-mode and Markdown
Plain text
PDF files (if you have pdftotext from poppler-utils installed)
YAML, TOML, JSON, HTML, CSS

Files over 1MB are skipped (configurable), and the usual suspects like .git, node_modules, __pycache__ are excluded automatically.

The index gets saved into ~/.emacs.d/ollama-buddy/rag-indexes/ as a .rag file named after the directory. You can see what you’ve got with M-x ollama-buddy-rag-list-indexes.

The chunking strategy

One thing I’m quite happy with here is the chunking. Rather than just splitting on a fixed character count, documents are split into overlapping word-based chunks. The defaults are:

(setq ollama-buddy-rag-chunk-size 400) ; ~500 tokens per chunk
(setq ollama-buddy-rag-chunk-overlap 50) ; 50-word overlap between chunks

The overlap is important - it means a piece of information that sits right at a chunk boundary doesn’t get lost. Each chunk also tracks its source file and line numbers, so you can see exactly where a result came from.

Searching and attaching context

Once you have an index, there are two main ways to use it:

M-x ollama-buddy-rag-search - searches and displays the results in a dedicated buffer so you can read through them
M-x ollama-buddy-rag-attach - searches and attaches the results directly to your chat context

The second one is the useful one for day-to-day work. After running it, your next chat message will automatically include the retrieved document chunks as context. The status line shows ♁N (where N is the number of attached searches) so you always know what context is in play. Clear everything with M-x ollama-buddy-clear-attachments or C-c 0.

You can also trigger searches inline using the @rag() syntax directly in your prompt and is something fun I have been working on to include an inline command language of sorts, but more about that in a future post.

The similarity search uses cosine similarity with sensible defaults (hopefully!)

(setq ollama-buddy-rag-top-k 5) ; return top 5 matching chunks
(setq ollama-buddy-rag-similarity-threshold 0.3) ; filter out low-relevance results

Bump top-k if you want more context, lower the threshold if you’re not getting enough results.

A practical example

Say you’ve been working on a large Emacs package and you want the LLM to help you understand something specific. You’d do:

M-x ollama-buddy-rag-index-directory → point at your project directory
Wait for indexing to complete (the chat header-line shows progress)
M-x ollama-buddy-rag-attach → type your search query, e.g. “streaming filter process”
Ask your question in the chat buffer as normal

The LLM now has the relevant source chunks as context and can give you a much more grounded answer than it would cold.

And the important aspect, especially regarding local models which don’t often have the huge context sizes often found in online LLMs is that it allows for very efficient context retrieval.

That’s pretty much it!

The whole thing is self-contained inside Emacs, no external packages or vector databases, you index once, search as needed, and the LLM gets actual information rather than hallucinating answers about your codebase or anything else that you would want to ingest and it will hopefully make working with local LLMs through ollama noticeably more useful and accurate.

Ollama Buddy v2.0 - LLMs can now call Emacs functions!

James Dyer — Mon, 16 Feb 2026 08:56:00 +0000

Tool calling has landed in ollama-buddy!, it’s originally not something I really thought I would end up doing, but as ollama has provided tool enabled models and an API for this feature then I felt obliged to add it. So now LLMs through ollama can now actually do things inside Emacs rather than just talk about them, my original “do things only in the chat buffer and copy and paste” might have gone right out the window in an effort to fully support the ollama API!

What is Tool Calling?

The basic idea is simple: instead of the model only generating text, it can request to invoke functions. You ask “what files are in my project?”, and instead of guessing, the model calls list_directory, gets the real answer, and responds with actual information.

This creates a conversational loop:

You send a prompt
The model decides it needs to call a tool
ollama-buddy executes the tool and feeds the result back
The model generates a response using the real data
Steps 2-4 repeat if more tools are needed

All of this is transparent - you just see the final response in the chat buffer.

The new ollama-buddy-tools.el module ships with 8 built-in tools:

Safe tools (read-only, enabled by default):

read_file - read file contents
list_directory - list directory contents
get_buffer_content - read an Emacs buffer
list_buffers - list open buffers with optional regex filtering
search_buffer - regex search within a buffer
calculate - evaluate math expressions via calc-eval

Unsafe tools (require safe mode off):

write_file - write content to files
execute_shell - run shell commands

Safe mode is on by default, so the model can only read - it can’t modify anything unless you explicitly allow it, I think this is quite a nice simple implementation, at the moment I generally have safe mode off but always allowing confirmation for each tool action, but of course you can configure as necessary.

Example Session

With a tool-capable model like qwen3:8b and tools enabled (C-c W):

>> PROMPT: What defuns are defined in ollama-buddy-tools.el?

The model calls search_buffer with a regex pattern, gets the list of function definitions, and gives you a nicely formatted summary. No copy-pasting needed.

Custom Tools

You can register your own tools with ollama-buddy-tools-register:

 (ollama-buddy-tools-register
'my-tool
"Description of what the tool does"
'((type . "object")
(required . ["param1"])
(properties . ((param1 . ((type . "string")
(description . "Parameter description"))))))
(lambda (args)
(let ((param1 (alist-get 'param1 args)))
(format "Result: %s" param1)))
t) ; t = safe tool

The registration API takes a name, description, JSON schema for parameters, an implementation function, and a safety flag. The model sees the schema and decides when to call your tool based on the conversation.

A ⚒ symbol now appears next to tool-capable models everywhere - header line, model selector (C-c m), and model management buffer (C-c M). This follows the same pattern as the existing ⊙ vision indicator, so you can see at a glance which models support tools.

That’s it. Pull a tool-capable model (qwen3, llama3.1, mistral, etc.) or use an online tool enabled model from ollama and start chatting. Next up is probably some web searching!, as again the ollama API supports this, so you will be able to pull in the latest from the interwebs to augment your prompt definition!

Automatically Syncing Emacs Tab Bar Styling With Your Theme

James Dyer — Wed, 11 Feb 2026 18:26:00 +0000

If you’ve ever enabled a new theme and noticed your tab-bar faces stubbornly hanging onto old colours or custom tweaks, I have found often that the tab-bar, tab-bar-tab, and tab-bar-tab-inactive faces don’t always blend cleanly with freshly loaded themes — especially of the older variety (a bit like me) and especially ones that came out before the tab bar was introduced into Emacs.

So how about a simple solution?, Can I implement something, that whenever I load a theme, the tab-bar faces update based on the theme’s default faces to establish a visually pleasant and coherent look?

Yes, yes I can!; the result is a tiny Elisp enhancement that hooks directly into Emacs’ theme-loading process.

Firstly however we need to have a method that will reliably pass over the themes default faces to the tab-bar. Here’s the function that realigns the tab-bar styling with your active theme:

(defun selected-window-accent-sync-tab-bar-to-theme ()
"Synchronize tab-bar faces with the current theme."
(interactive)
(let ((default-bg (face-background 'default))
(default-fg (face-foreground 'default))
(inactive-fg (face-foreground 'mode-line-inactive)))
(custom-set-faces
`(tab-bar ((t (:inherit default :background ,default-bg :foreground ,default-fg))))
`(tab-bar-tab ((t (:inherit default :background ,default-fg :foreground ,default-bg))))
`(tab-bar-tab-inactive ((t (:inherit default :background ,default-bg :foreground ,inactive-fg)))))))

This simply rebuilds the key tab-bar faces so they derive their colours from the current theme’s normal face definitions, so any old themes should now not leave the tab bar faces hanging.

Now for the function activation; Emacs 29 introduced enable-theme-functions, a hook that runs every time a theme is enabled — perfect for our use case, but as always I have my eye on older Emacs versions, so lets fall back to a classic approach: advice on load-theme.

Here’s a version‑aware setup that does the right thing automatically:

(if (version<= "29.1" emacs-version)
;; Emacs 29.1+ — use the official theme hook
(add-hook 'enable-theme-functions
(lambda (_theme)
(selected-window-accent-sync-tab-bar-to-theme)))
;; Older Emacs — fall back to advising load-theme
(progn
(defun selected-window-accent-sync-tab-bar-to-theme--after (&rest _)
(selected-window-accent-sync-tab-bar-to-theme))
(advice-add 'load-theme :after
#'selected-window-accent-sync-tab-bar-to-theme--after)))

With this tweak in place, every time you change themes, your tab-bar instantly updates, colours stay consistent, clean, and theme‑accurate without you having to do anything at all! The downside to this of course is that any newer themes that were created after the advent of the tab bar in Emacs will have their tab-bar faces overridden, but for me this solution is good enough and gives a pleasant coherent visual tab bar experience.

Yay!, yet another Yak shaved!

Spent a bit of free time polishing ollama-buddy - github Copilot is now onboard!

James Dyer — Wed, 04 Feb 2026 10:40:00 +0000

I’ve had a little free time recently (figuring out this baby stuff!) and thought I would spend time revisiting and refining my AI assistant ollama-buddy

I’ve been playing around with agentic coding and keeping up-to-date on the rapid development of the Emacs AI package landscape and I think I have refined in my own mind my idea of what I would like to see in an Emacs AI assistant.

The headline change regarding the latest release of ollama-buddy is GitHub Copilot integration; the rest of the work is about smoothing the UI and simplifying day-to-day use.

What’s new - the Copilot addition (v1.2)

GitHub Copilot Chat API support via a new file, ollama-buddy-copilot.el, so Copilot models can be used alongside your existing providers.
Authentication uses GitHub’s device flow (OAuth). No API key required: M-x ollama-buddy-copilot-login opens a browser and guides you through secure authentication.
Copilot models are identified with a “p:” prefix (for example, p:gpt-4o). The header line shows a “p” indicator when the Copilot provider is loaded so you always know it’s available.
Copilot access exposes a broad set of models from multiple vendors through the Copilot interface: OpenAI (gpt-4o, gpt-5), Anthropic (claude-sonnet-4, claude-opus-4.5), Google (gemini-2.5-pro), and xAI models.
Quick usage notes:
1. Ensure you have an active GitHub Copilot subscription.
2. Run M-x ollama-buddy-copilot-login.
3. Enter the device code in your browser at github.com/login/device when prompted.
4. Select a Copilot model with C-c m (e.g., p:gpt-4o).
Example config to load Copilot support:

(use-package ollama-buddy
:bind
("C-c o" . ollama-buddy-menu)
("C-c O" . ollama-buddy-transient-menu-wrapper)
:config
(require 'ollama-buddy-copilot nil t))

Other notable updates in this release series

v1.2.1 (2026-02-02)
- Attachment count indicator on the header line so you get a constant visual reminder that the session has attachments.
v1.1.5 (2026-01-31)
- Global system prompt feature (enabled by default): sets a baseline set of instructions (for example, to prefer plain prose and avoid markdown tables) that is prepended to session-specific system prompts. This helps keep responses consistent across providers and things like malformed markdown tables for example, which seems to be common. There’s a toggle (ollama-buddy-global-system-prompt-enabled) and a quick command to flip it (ollama-buddy-toggle-global-system-prompt), plus a transient-menu entry.
- Consolidated model management: streamlined into a single model management buffer (C-c W) and the welcome screen now points to that buffer for model tasks.
v1.1.4 (2026-01-31)
- Header-line and keybinding cleanup: C-c RET to send prompts (matches gptel, as I feel this seems intuitive), removed a redundant backend indicator, shortened the markdown indicator to “MD”, and fixed markdown → org heading conversion to keep structure sane.
v1.1.3 (2026-01-31)
- Chat UX improvements and simplification: added ollama-buddy-auto-scroll (default nil — don’t auto-scroll so you can read while streaming) and ollama-buddy-pulse-response (flashes the response on completion, taking from gptel again, as if there is no autoscrolling it is useful to visually see when the response has completed). Removed the model name coloring feature and related toggles to simplify code and improve org-mode performance.
v1.1.2 (2026-01-30)
- Streamlined welcome screen and model selection, clearer provider indicators in the header line and an improved list of enabled online LLM providers.

Ollama buddy now supports cloud models!

James Dyer — Wed, 28 Jan 2026 08:29:00 +0000

Having another look at my AI assistant - ollama-buddy, its been a while and it seems ollama has moved on since I started creating this package last year, so I have developed a new roadmap and the first step is to add ollama cloud models!

Here are some references to the project, including a youtube channel where I upload ollama-buddy demonstrations:

https://melpa.org/#/ollama-buddy

https://github.com/captainflasmr/ollama-buddy

Here is the changelog for the cloud model implementation:

<2026-01-28 Wed> 1.1

Added Ollama Cloud Models support

Cloud models (running on ollama.com infrastructure) now work seamlessly
ollama-buddy-cloud-signin to automatically open browser for authentication
Cloud models are proxied through the local Ollama server which handles authentication
Use C-u C-c m or transient menu “Model > Cloud” to select cloud models
Status line shows ☁ indicator when using a cloud model
Available cloud models include: qwen3-coder:480b-cloud, deepseek-v3.1:671b-cloud, gpt-oss:120b-cloud, minimax-m2.1:cloud, and more

Auto-Populating Weekly Dates in Org-Mode Tables

James Dyer — Mon, 26 Jan 2026 10:13:00 +0000

Here is just a quick one, I was working with an org-mode table for tracking work weeks and needed to auto-populate a Date column where each row increments by exactly one week. The table structure looked like this:

The first row has a base date (2026-01-05), and I wanted subsequent rows to automatically calculate as weekly increments: 2026-01-12, 2026-01-19, and so on.

Initially, I tried several approaches that seemed logical but encountered #ERROR results and eventually settled on a working solution which is to hardcode the base date directly in the formula:

#+TBLFM: $3='(format-time-string "%Y-%m-%d" (time-add (date-to-time "2026-01-05") (* (- @# 2) 7 24 3600)))

which gave:

and I can now of course extend the table for all the weeks in the year and I don’t have to fill in manually any more!

Here’s how it works:

(date-to-time "2026-01-05") - Convert the hardcoded base date to Emacs time format
(- @# 2) - Calculate the offset from the base row
(* (- @# 2) 7 24 3600) - Convert the offset to seconds (weeks × days × hours × seconds)
time-add - Add the offset to the base date
format-time-string "%Y-%m-%d" - Format back to ISO date string

Speed Reading in Emacs: Building an RSVP Reader

James Dyer — Sun, 18 Jan 2026 10:30:00 +0000

I recently came across a fascinating video titled “How Fast Can You Read? - Speed Reading Challenge” that demonstrated the power of RSVP (Rapid Serial Visual Presentation) for speed reading. The concept is quite nice and simple and I vaguely remember seeing something about it a few years back. Instead of your eyes scanning across lines of text, words are presented one at a time in a fixed position. This eliminates the mechanical overhead of eye movements and can dramatically increase reading speed!

So, I immediately wondered, could I build this into Emacs?, actually no, firstly I thought, are there any packages for Emacs that can do this?, of course there are!, the spray package from MELPA is a more mature, feature-rich option if you’re looking for production-ready RSVP reading in Emacs, and also there is speedread. However, there’s something satisfying about having a compact, single-function solution that does exactly what you need, so lets see if I can build one!

RSVP works by displaying words sequentially in the same location on screen. Your eyes remain stationary, focused on a single point, while words flash by at a controlled pace. This technique can boost reading speeds to 300-600+ words per minute, compared to typical reading speeds of 200-300 WPM.

The key innovation is the Optimal Recognition Point (ORP) - typically positioned about one-third into each word. This is where your eye naturally fixates when reading. By aligning each word’s ORP at the same screen position, RSVP creates an optimal visual flow.

Given Emacs’ extensive text processing capabilities, this sounds something that Emacs could eat for breakfast. Here is what I came up with:

Here is a quick video of my implementation:

and the defun:

(defun rsvp-minibuffer ()
 "Display words from point (or mark to point) in minibuffer using RSVP.
Use f/s for speed, [/] for size, b/n to skip, SPC to pause, q to quit."
 (interactive)
 (let* ((start (if (region-active-p) (region-beginning) (point)))
 (end (if (region-active-p) (region-end) (point-max)))
 (text (buffer-substring-no-properties start end))
 (wpm 350) (font-size 200) (orp-column 20)
 (word-positions '()) (pos 0) (i 0)
 (message-log-max nil)) ; Disable message logging
 ;; Build word positions list
 (dolist (word (split-string text))
 (unless (string-blank-p word)
 (when-let ((word-start (string-match (regexp-quote word) text pos)))
 (push (cons word (+ start word-start)) word-positions)
 (setq pos (+ word-start (length word))))))
 (setq word-positions (nreverse word-positions))
 ;; Display loop
 (while (< i (length word-positions))
 (let* ((word (car (nth i word-positions)))
 (word-pos (cdr (nth i word-positions)))
 (word-len (length word))
 (delay (* (/ 60.0 wpm)
 (cond ((< word-len 3) 0.8) ((> word-len 8) 1.3) (t 1.0))
 (if (string-match-p "[.!?]$" word) 1.5 1.0)))
 (orp-pos (/ word-len 3))
 (face-mono `(:height ,font-size :family "monospace"))
 (face-orp `(:foreground "red" :weight normal ,@face-mono))
 (padded-word (concat
 (propertize (make-string (max 0 (- orp-column orp-pos)) ?\s) 'face face-mono)
 (propertize (substring word 0 orp-pos) 'face face-mono)
 (propertize (substring word orp-pos (1+ orp-pos)) 'face face-orp)
 (propertize (substring word (1+ orp-pos)) 'face face-mono))))
 (goto-char (+ word-pos word-len))
 (message "%s" padded-word)
 (pcase (read-event nil nil delay)
 (?f (setq wpm (min 1000 (+ wpm 50))))
 (?s (setq wpm (max 50 (- wpm 50))))
 (?\[ (setq font-size (max 100 (- font-size 20))))
 (?\] (setq font-size (min 400 (+ font-size 20))))
 (?b (setq i (max 0 (- i 10))))
 (?n (setq i (min (1- (length word-positions)) (+ i 10))))
 (?\s (read-event (format "%s [PAUSED - WPM: %d]" padded-word wpm)))
 (?q (setq i (length word-positions)))
 (_ (setq i (1+ i))))))))

The function calculates the ORP as one-third through each word and highlights it in red. By padding each word with spaces, the ORP character stays perfectly aligned in the same column, creating that crucial stationary focal point.

To ensure pixel-perfect alignment, the function explicitly sets a monospace font family for all displayed text. Without this, proportional fonts would cause the ORP to drift slightly between words, although I think at times there is a little waddle, but it is good enough.

Also, Not all words are created equal:

Short words (< 3 characters) display 20% faster
Long words (> 8 characters) display 30% slower
Words ending in punctuation (.!?) get 50% more time

This mimics natural reading rhythms where you’d naturally pause at sentence boundaries.

While reading, you can try these keybindings: (which I borrowed off spray)

f / s - Speed up or slow down (±50 WPM)
[ / ] - Decrease or increase font size
b / n - Skip backward or forward by 10 words
SPC - Pause (press any key to resume)
q - Quit
C-g - Emergency quit

Also The function tracks each word’s position in the original buffer and updates point as you read. This means:

You can see where you are in the text
When you quit, your cursor is at the last word you read
You can resume reading by running the function again

To use it, simply:

Position your cursor where you want to start reading (or select a region)
Run M-x rsvp-minibuffer
Watch the words flow in the minibuffer

The function works from point to end of buffer, or if you have an active region, it only processes the selected text.

If you’re curious about RSVP reading, drop this function into your Emacs config and give it a try. Start at 300-350 WPM and see how it feels. You might be surprised at how much faster you can consume text when your eyes aren’t constantly moving across the page.

The code is simple enough to customize - adjust the default WPM, change the ORP colour, modify the timing multipliers, or add new controls. That’s the beauty of Emacs, if you can imagine it, you can build it.

A single function ripgrep alternative to rgrep

James Dyer — Fri, 09 Jan 2026 09:43:00 +0000

For years, rgrep has been the go-to solution for searching codebases in Emacs. It’s built-in, reliable, and works everywhere. But it’s slow on large projects and uses the aging find and grep commands.

Packages like deadgrep and rg.el provide ripgrep integration, and for years I used deadgrep and really liked it. But what if you could get ripgrep’s speed with just a single function you paste into your config?

This post introduces a ~100 line defun that replaces rgrep, no packages, no dependencies, just pure Elisp. It’s fast, asynchronous, works offline, and mimics rgrep’s familiar interface so it can leverage grep-mode

So, why not just use rgrep?

I think that rgrep has three main limitations:

Firstly, speed. On a project with 10,000+ files, rgrep can take 15-30 seconds. Ripgrep completes the same search in under a second.

Secondly, file ignoring, rgrep requires manually configuring grep-find-ignored-directories or grep-find-ignored-files, I had the following typical configuration for rgrep, but it wasn’t as flexible as I would like it to be:

(eval-after-load 'grep
 '(progn
 (dolist (dir '("nas" ".cache" "cache" "elpa" "chromium" ".local/share" "syncthing" ".mozilla" ".local/lib" "Games"))
 (push dir grep-find-ignored-directories))
 (dolist (file '(".cache" "*cache*" "*.iso" "*.xmp" "*.jpg" "*.mp4"))
 (push file grep-find-ignored-files))
 ))

Ripgrep automatically respects an .ignore file. Just create an .ignore file in your project root and list patterns to exclude, this is just a simple text file, universally applied across all searches and any changes can be easily applied.

Thirdly, modern features. Ripgrep includes smart-case search, better regex support, and automatic binary file detection. Of course, there is a context that can be displayed around the found line, but in order to get ripgrep to work with grep-mode, this is not really doable, and it’s not something I need anyway.

Here is the complete ripgrep implementation that you can paste directly into your init.el:

(defun my/grep (search-term &optional directory glob)
 "Run ripgrep (rg) with SEARCH-TERM and optionally DIRECTORY and GLOB.
If ripgrep is unavailable, fall back to Emacs's rgrep command. Highlights SEARCH-TERM in results.
By default, only the SEARCH-TERM needs to be provided. If called with a
universal argument, DIRECTORY and GLOB are prompted for as well."
 (interactive
 (let* ((univ-arg current-prefix-arg)
 (default-search-term
 (cond
 ((use-region-p)
 (buffer-substring-no-properties (region-beginning) (region-end)))
 ((thing-at-point 'symbol t))
 ((thing-at-point 'word t))
 (t ""))))
 (list
 (read-string (if (string-empty-p default-search-term)
 "Search for: "
 (format "Search for (default `%s`): " default-search-term))
 nil nil default-search-term)
 (when univ-arg (read-directory-name "Directory: "))
 (when univ-arg (read-string "File pattern (glob, default: ): " nil nil "")))))
 (let* ((directory (expand-file-name (or directory default-directory)))
 (glob (or glob ""))
 (buffer-name "*grep*"))
 (if (executable-find "rg")
 (let ((buffer (get-buffer-create buffer-name)))
 (with-current-buffer buffer
 (setq default-directory directory)
 (let ((inhibit-read-only t))
 (erase-buffer)
 (insert (format "-*- mode: grep; default-directory: \"%s\" -*-\n\n" directory))
 (if (not (string= "" glob))
 (insert (format "[o] Glob: %s\n\n" glob)))
 (insert "Searching...\n\n"))
 (grep-mode)
 (setq-local my/grep-search-term search-term)
 (setq-local my/grep-directory directory)
 (setq-local my/grep-glob glob))

 (pop-to-buffer buffer)
 (goto-char (point-min))

 (make-process
 :name "ripgrep"
 :buffer buffer
 :command `("rg" "--color=never" "--max-columns=500"
 "--column" "--line-number" "--no-heading"
 "--smart-case" "-e" ,search-term
 "--glob" ,glob ,directory)
 :filter (lambda (proc string)
 (when (buffer-live-p (process-buffer proc))
 (with-current-buffer (process-buffer proc)
 (let ((inhibit-read-only t)
 (moving (= (point) (process-mark proc))))
 (setq string (replace-regexp-in-string "[\r\0\x01-\x08\x0B-\x0C\x0E-\x1F]" "" string))
 ;; Replace full directory path with ./ in the incoming output
 (setq string (replace-regexp-in-string
 (concat "^" (regexp-quote directory))
 "./"
 string))
 (save-excursion
 (goto-char (process-mark proc))
 (insert string)
 (set-marker (process-mark proc) (point)))
 (if moving (goto-char (process-mark proc)))))))
 :sentinel
 (lambda (proc _event)
 (when (memq (process-status proc) '(exit signal))
 (with-current-buffer (process-buffer proc)
 (let ((inhibit-read-only t))
 ;; Remove "Searching..." line
 (goto-char (point-min))
 (while (re-search-forward "Searching\\.\\.\\.\n\n" nil t)
 (replace-match "" nil t))

 ;; Clean up the output - replace full paths with ./
 (goto-char (point-min))
 (forward-line 3)
 (let ((start-pos (point)))
 (while (re-search-forward (concat "^" (regexp-quote directory)) nil t)
 (replace-match "./" t t))

 ;; Check if any results were found
 (goto-char start-pos)
 (when (= (point) (point-max))
 (insert "No results found.\n")))

 (goto-char (point-max))
 (insert "\nRipgrep finished\n")

 ;; Highlight search terms using grep's match face
 (goto-char (point-min))
 (forward-line 3)
 (save-excursion
 (while (re-search-forward (regexp-quote search-term) nil t)
 (put-text-property (match-beginning 0) (match-end 0)
 'face 'match)
 (put-text-property (match-beginning 0) (match-end 0)
 'font-lock-face 'match))))

 ;; Set up keybindings
 (local-set-key (kbd "D")
 (lambda ()
 (interactive)
 (my/grep my/grep-search-term
 (read-directory-name "New search directory: ")
 my/grep-glob)))
 (local-set-key (kbd "S")
 (lambda ()
 (interactive)
 (my/grep (read-string "New search term: "
 nil nil my/grep-search-term)
 my/grep-directory
 my/grep-glob)))
 (local-set-key (kbd "o")
 (lambda ()
 (interactive)
 (my/grep my/grep-search-term
 my/grep-directory
 (read-string "New glob: "))))
 (local-set-key (kbd "g")
 (lambda ()
 (interactive)
 (my/grep my/grep-search-term my/grep-directory my/grep-glob)))

 (goto-char (point-min))
 (message "ripgrep finished."))))
 )
 (message "ripgrep started..."))
 ;; Fallback to rgrep
 (progn
 (setq default-directory directory)
 (message (format "%s : %s : %s" search-term glob directory))
 (rgrep search-term (if (string= "" glob) "*" glob) directory)))))

That’s it. ~100 lines. No dependencies. No packages to manage! (well except ripgrep of course)

Now that I have complete control over this function, I have added further improvements over rgrep, inspired by deadgrep

S - New search term
D - New directory
o - New glob pattern
g - Re-run current search

and a universal argument can be passed through to set these up on the initial grep

I have tried to make the output as similar as possible to rgrep, to be compatible with grep-mode and for familiarity, so it will be something like:

-*- mode: grep; default-directory: "~/project/" -*-
[o] Glob: *.el
./init.el:42:10:(defun my-function ()
./config.el:156:5: (my-function)
./helpers.el:89:12:;; Helper for my-function
Ripgrep finished

and if a glob is applied it will display the glob pattern.

Its perfect for offline environments, and yes, I’m banging on about this again!, no network, no package manager, no dependencies (except ripgrep of course!)

New package dired-video-thumbnail added to MELPA!

James Dyer — Wed, 31 Dec 2025 18:34:00 +0000

I have created another package!, this time something that I thought was missing from the mighty Emacs and that is the ability to show video thumbnails in a grid and to be able to filter, sort e.t.c. Basically like an enhanced image-dired. I have been increasingly using image-dired for my image editing and management needs and am always adding little improvements, to such an extent I decided to create a video thumb grid package, enjoy!

Introduction

dired-video-thumbnail is an Emacs package that provides image-dired style thumbnail viewing for video files. It extracts thumbnails from videos using ffmpeg and displays them in a grid layout, allowing you to visually browse and manage video collections directly from Emacs.

Features

Thumbnail grid display - View video thumbnails in a configurable grid layout
Persistent caching - Thumbnails are cached and only regenerated when the source file changes
Async generation - Emacs remains responsive while thumbnails are generated in the background
Dired integration - Marks sync bidirectionally with the associated dired buffer
Visual mark indication - Marked thumbnails display a coloured border (like image-dired)
Dynamic header line - Shows filename, dimensions, duration, and file size for the current video
Click to play - Open videos in your preferred external player
Cross-platform - Works on Linux, macOS, and Windows
Resizable thumbnails - Adjust thumbnail size on the fly
Sorting - Sort videos by name, date, size, or duration
Filtering - Filter videos by name pattern, duration range, or file size
Recursive search - Browse videos across subdirectories with optional auto-recursive mode
Transient menu - Comprehensive command menu accessible via . or C-c .

Whats New

<2025-12-15 Mon> 0.3.0

Added transient menu interface

Introduced a comprehensive transient menu (dired-video-thumbnail-transient) providing quick access to all commands via . or C-c . in the thumbnail buffer. The menu displays current state (sort order, filters, video count, recursive/wrap mode) and organises commands into logical groups: Navigation, Playback, Sorting, Filtering, Marking, Delete, Display, and Other.

<2025-12-15 Mon> 0.2.0

Enhanced package with sorting, filtering, and docs

Added sorting and filtering features to dired-video-thumbnail. Introduced customizable options for sorting and filtering criteria, and implement interactive commands for toggling these settings. Included comprehensive documentation in Texinfo format, covering installation, usage, and customization.

Requirements

Emacs 28.1 or later
ffmpeg and ffprobe installed and available in your PATH
transient 0.4.0 or later (for the transient menu)

Installation

Manual

Download dired-video-thumbnail.el and place it in your load-path:

(add-to-list 'load-path "/path/to/dired-video-thumbnail/")
(require 'dired-video-thumbnail)

use-package

(use-package dired-video-thumbnail
 :load-path "/path/to/dired-video-thumbnail/"
 :bind (:map dired-mode-map
 ("C-t v" . dired-video-thumbnail)))

straight.el

(straight-use-package
 '(dired-video-thumbnail :type git :host github :repo "captainflasmr/dired-video-thumbnail"))

Usage

Basic Usage

Open a directory containing video files in dired
Run M-x dired-video-thumbnail
A new buffer opens displaying thumbnails for all videos in the directory
The cursor automatically moves to the first thumbnail

With Marked Files

In dired, mark specific video files with m
Run M-x dired-video-thumbnail
Only thumbnails for the marked videos are displayed

Recursive Mode

To include videos from subdirectories:

Use C-u M-x dired-video-thumbnail (with prefix argument)
Or run M-x dired-video-thumbnail-recursive
Or press R in the thumbnail buffer to toggle recursive mode

When dired-video-thumbnail-auto-recursive is enabled (the default), the package automatically searches subdirectories if the current directory contains no video files.

Suggested Keybinding

Add a keybinding in dired for quick access:

(with-eval-after-load 'dired
 (define-key dired-mode-map (kbd "C-t v") #'dired-video-thumbnail))

Press . or C-c . in the thumbnail buffer to open the transient menu. This provides a comprehensive interface to all commands with a live status display.

State: Sort: name ↑ | Videos: 42 | Recursive: OFF | Wrap: ON

Navigation Playback Sorting Filtering
n Next RET Play video s Sort menu... / Filter menu...
p Previous o Play video S Interactive sort \ Interactive filter
C-n Next row r Reverse order c Clear filters
C-p Previous row
d Go to dired

Marking Delete Display Other
m Mark menu... D Delete v Display menu... g Regenerate thumbnail
M Mark all x Delete marked+ Larger thumbnails G Regenerate all
U Unmark all - Smaller thumbnails C Clear cache
t Toggle all marks w Toggle wrap ? Help
 R Toggle recursive q Quit menu
 Q Quit buffer

The status line at the top shows:

Current sort criteria and direction (e.g., name ↑)
Number of videos displayed (and total if filtered)
Recursive mode status
Wrap display mode status
Active filters (if any)

Submenus

Several keys open submenus with additional options:

s - Sort menu: Sort by name, date, size, or duration; reverse order
/ - Filter menu: Filter by name regexp, duration range, or size range; clear filters
m - Mark menu: Mark/unmark current, toggle current, mark/unmark/toggle all
v - Display menu: Adjust size, toggle wrap/recursive, refresh, regenerate thumbnails

Header Line

As you navigate between thumbnails, the header line dynamically displays information about the current video:

Mark indicator - A red * if the video is marked
Filename - The video filename in bold
Dimensions - Video resolution (e.g., 1920x1080)
Duration - Video length (e.g., 5:32 or 1:23:45)
File size - Size in MB (e.g., 45.2 MB)

The header also shows current sort settings (e.g., [name ↑]), active filters, and a [recursive] indicator when browsing subdirectories.

Keybindings

In the *Video Thumbnails* buffer:

Key	Command	Description
`.`	`dired-video-thumbnail-transient`	Open transient menu
`C-c .`	`dired-video-thumbnail-transient`	Open transient menu

Key	Command	Description
`n`	`dired-video-thumbnail-next`	Move to next thumbnail
`p`	`dired-video-thumbnail-previous`	Move to previous thumbnail
`SPC`	`dired-video-thumbnail-play`	Play video at point
`C-f`	`dired-video-thumbnail-forward`	Move to next thumbnail
`C-b`	`dired-video-thumbnail-backward`	Move to previous thumbnail
`<right>`	`dired-video-thumbnail-forward`	Move to next thumbnail
`<left>`	`dired-video-thumbnail-backward`	Move to previous thumbnail
`<up>`	`dired-video-thumbnail-previous-row`	Move up one row
`<down>`	`dired-video-thumbnail-next-row`	Move down one row
`d`	`dired-video-thumbnail-goto-dired`	Switch to associated dired buffer
`q`	`quit-window`	Close the thumbnail buffer
`Q`	`dired-video-thumbnail-quit-and-kill`	Quit and kill the buffer

Playback

Key	Command	Description
`RET`	`dired-video-thumbnail-play`	Play video at point
`o`	`dired-video-thumbnail-play`	Play video at point
`mouse-1`	`dired-video-thumbnail-play`	Play video (click)

On Linux, videos open with xdg-open. On macOS, they open with open. On Windows, they open with the system default player. You can also specify a custom player.

Marking

Marks are synchronised with the associated dired buffer, so marking a video in the thumbnail view also marks it in dired, and vice versa.

Key	Command	Description
`m`	`dired-video-thumbnail-mark`	Mark video and move to next
`u`	`dired-video-thumbnail-unmark`	Unmark video and move to next
`mouse-3`	`dired-video-thumbnail-toggle-mark`	Toggle mark (right-click)
`M`	`dired-video-thumbnail-mark-all`	Mark all videos
`U`	`dired-video-thumbnail-unmark-all`	Unmark all videos
`t`	`dired-video-thumbnail-toggle-all-marks`	Invert all marks

Deletion

Key	Command	Description
`D`	`dired-video-thumbnail-delete`	Delete video at point (with confirmation)
`x`	`dired-video-thumbnail-delete-marked`	Delete marked videos (with confirmation)

Display

Key	Command	Description
`+`	`dired-video-thumbnail-increase-size`	Increase thumbnail size
`-`	`dired-video-thumbnail-decrease-size`	Decrease thumbnail size
`r`	`dired-video-thumbnail-refresh`	Refresh the display
`w`	`dired-video-thumbnail-toggle-wrap`	Toggle wrap mode (flow vs fixed cols)
`R`	`dired-video-thumbnail-toggle-recursive`	Toggle recursive directory search
`g`	`dired-video-thumbnail-regenerate`	Regenerate thumbnail at point
`G`	`dired-video-thumbnail-regenerate-all`	Regenerate all thumbnails

Sorting

Key	Command	Description
`S`	`dired-video-thumbnail-sort`	Interactive sort menu
`sn`	`dired-video-thumbnail-sort-by-name`	Sort by filename
`sd`	`dired-video-thumbnail-sort-by-date`	Sort by modification date
`ss`	`dired-video-thumbnail-sort-by-size`	Sort by file size
`sD`	`dired-video-thumbnail-sort-by-duration`	Sort by video duration
`sr`	`dired-video-thumbnail-sort-reverse`	Reverse sort order

Filtering

Key	Command	Description
`\`	`dired-video-thumbnail-filter`	Interactive filter menu
`/n`	`dired-video-thumbnail-filter-by-name`	Filter by name regexp
`/d`	`dired-video-thumbnail-filter-by-duration`	Filter by duration range
`/s`	`dired-video-thumbnail-filter-by-size`	Filter by size range
`/c`	`dired-video-thumbnail-filter-clear`	Clear all filters
`//`	`dired-video-thumbnail-filter-clear`	Clear all filters

Help

Key	Command	Description
`h`	`dired-video-thumbnail-help`	Show help
`?`	`dired-video-thumbnail-help`	Show help

Customisation

All customisation options are in the dired-video-thumbnail group. Use M-x customize-group RET dired-video-thumbnail RET to browse them interactively.

Thumbnail Cache Location

Thumbnails are stored in ~/.emacs.d/dired-video-thumbnails/ by default:

(setq dired-video-thumbnail-cache-dir "~/path/to/cache/")

Thumbnail Size

Control the generated thumbnail size and display height:

(setq dired-video-thumbnail-size 200) ;; Generated thumbnail size (pixels)
(setq dired-video-thumbnail-display-height 150) ;; Display height in buffer

Thumbnails are generated as squares to ensure consistent grid alignment regardless of video aspect ratio.

Grid Layout

Set the number of columns in the thumbnail grid:

(setq dired-video-thumbnail-columns 4)

Wrap Display

Control whether thumbnails wrap to fill the window width:

(setq dired-video-thumbnail-wrap-display t) ;; Wrap to window width (default)
(setq dired-video-thumbnail-wrap-display nil) ;; Use fixed columns
(setq dired-video-thumbnail-spacing 4) ;; Spacing between thumbnails (pixels)

Thumbnail Timestamp

By default, thumbnails are extracted at 5 seconds into the video. Change this to get a more representative frame:

(setq dired-video-thumbnail-timestamp "00:00:10") ;; 10 seconds in
(setq dired-video-thumbnail-timestamp "00:01:00") ;; 1 minute in
(setq dired-video-thumbnail-timestamp nil) ;; Let ffmpeg choose

Video Player

Set your preferred video player:

(setq dired-video-thumbnail-video-player "mpv")
(setq dired-video-thumbnail-video-player "vlc")
(setq dired-video-thumbnail-video-player nil) ;; Use system default

When set to nil (the default), videos open with:

Linux: xdg-open
macOS: open
Windows: System default player (e.g., Films & TV)

Video Extensions

Add or modify recognised video file extensions:

(setq dired-video-thumbnail-video-extensions
 '("mp4" "mkv" "avi" "mov" "webm" "m4v" "wmv" "flv" "mpeg" "mpg" "ogv" "3gp"))

Mark Border Appearance

Marked thumbnails are indicated with a coloured border. Customise the border width and colour:

(setq dired-video-thumbnail-mark-border-width 4) ;; Border width in pixels

;; Change border colour via the face
(set-face-foreground 'dired-video-thumbnail-mark "blue")

Default Sorting

Set the default sort criteria and order:

(setq dired-video-thumbnail-sort-by 'name) ;; Options: name, date, size, duration
(setq dired-video-thumbnail-sort-order 'ascending) ;; Options: ascending, descending

Recursive Search

Control recursive directory searching behaviour:

(setq dired-video-thumbnail-recursive nil) ;; Always search recursively
(setq dired-video-thumbnail-auto-recursive t) ;; Auto-recursive when no local videos (default)

When dired-video-thumbnail-auto-recursive is enabled and the current directory has no video files but has subdirectories, the package automatically searches recursively.

ffmpeg Path

If ffmpeg/ffprobe are not in your PATH:

(setq dired-video-thumbnail-ffmpeg-program "/usr/local/bin/ffmpeg")
(setq dired-video-thumbnail-ffprobe-program "/usr/local/bin/ffprobe")

Example Configuration

(use-package dired-video-thumbnail
 :load-path "/path/to/dired-video-thumbnail/"
 :bind (:map dired-mode-map
 ("C-t v" . dired-video-thumbnail))
 :custom
 (dired-video-thumbnail-size 250)
 (dired-video-thumbnail-display-height 180)
 (dired-video-thumbnail-columns 5)
 (dired-video-thumbnail-timestamp "00:00:10")
 (dired-video-thumbnail-video-player nil) ;; Use system default
 (dired-video-thumbnail-mark-border-width 5)
 (dired-video-thumbnail-sort-by 'date)
 (dired-video-thumbnail-sort-order 'descending)
 (dired-video-thumbnail-auto-recursive t)
 :custom-face
 (dired-video-thumbnail-mark ((t (:foreground "orange")))))

Cache Management

Thumbnails are cached based on the file path and modification time. If you modify a video file, the thumbnail will be automatically regenerated on next view.

Video metadata (dimensions, duration) is also cached in memory to avoid repeated calls to ffprobe.

To manually clear the thumbnail cache:

M-x dired-video-thumbnail-clear-cache

Workflow Examples

Reviewing and Deleting Unwanted Videos

Open a directory with videos in dired
C-t v to open thumbnail view
Browse thumbnails with n, p, SPC, or arrow keys
Press D to delete individual videos, or mark with m and delete with x

Selecting Videos for Processing

Open thumbnail view with C-t v
Mark videos you want to process with m
Press d to switch to dired
Your marked videos are already selected in dired
Use any dired command (C, R, !, etc.) on marked files

Quick Video Preview

In dired, position cursor on a video file
C-t v opens thumbnail view
RET to play the video
q to return to dired

Finding Large Videos

Open thumbnail view with C-t v
Press . to open the transient menu
Press s then s to sort by size
Press r to reverse order (largest first)
Or use / then s to filter by size range

Finding Long Videos

Press . to open the transient menu
Press s then D to sort by duration
Or use / then d to filter by duration range (e.g., 5:00 to 30:00)

Searching by Name

Press . to open the transient menu
Press / then n and enter a regexp pattern
Only matching videos are shown
Press c to clear the filter

Troubleshooting

Thumbnails not generating

Ensure ffmpeg is installed: ffmpeg -version
Check that ffmpeg is in your PATH or set dired-video-thumbnail-ffmpeg-program
Try regenerating with g on a specific thumbnail

Placeholder showing instead of thumbnail

Some videos may fail to generate thumbnails if:

The video is corrupted
The timestamp is beyond the video duration (try setting dired-video-thumbnail-timestamp to nil)
ffmpeg doesn’t support the codec

Press g on the thumbnail to retry generation.

Video info not showing in header line

Ensure ffprobe is installed (it comes with ffmpeg). Set dired-video-thumbnail-ffprobe-program if it’s not in your PATH.

Marks not syncing with dired

Run M-x dired-video-thumbnail-debug to check if the dired buffer is properly associated. The output should show a live dired buffer reference.

Performance with many videos

The package processes up to 4 videos concurrently by default. For directories with hundreds of videos, initial thumbnail generation may take some time, but Emacs remains responsive and thumbnails appear as they complete.

image-dired - Built-in image thumbnail browser for dired
dirvish - A modern file manager for Emacs with preview support

Setting Up Emacs for C# Development on Windows

James Dyer — Tue, 16 Dec 2025 08:25:00 +0000

Introduction

I have been developing C# with .NET 9.0 for the last year on Windows and I thought it was probably time to write down my current setup, and maybe someone might even find this useful!

So, this guide documents my setup for running Emacs 30.1 on Windows with full C# development support, including LSP, debugging (through DAPE), and all the ancillary tools you’d expect from a modern development environment. The setup is designed to be portable and self-contained, which is particularly useful in air-gapped or restricted environments.

A version of this can be found at https://github.com/captainflasmr/Emacs-on-windows which will be a living continually updated version!

Prerequisites

Before we begin, you’ll need:

Windows 10 or 11 (64-bit)
.NET 9.0 SDK - Required for csharp-ls and building .NET projects
Visual Studio 2022 (optional) - Useful for MSBuild and if you need the full IDE occasionally
Administrator access - For initial setup only

You can verify your .NET installation by opening a command prompt and running:

dotnet --version

If you see version 9.0.x or later, you’re ready to proceed.

The Big Picture

Here’s what we’re building:

D:\source\emacs-30.1\
├── bin\
│ ├── emacs.exe, runemacs.exe, etc.
│ ├── PortableGit\ # Git for version control
│ ├── Apache-Subversion\ # SVN (if needed)
│ ├── csharp-ls\ # C# Language Server
│ ├── netcoredbg\ # .NET debugger
│ ├── omnisharp-win-x64\ # Alternative C# LSP
│ ├── hunspell\ # Spell checking
│ ├── find\ # ripgrep for fast searching
│ ├── ffmpeg-7.1.1-.../ # Video processing
│ └── ImageMagick-.../ # Image processing
└── share\
 └── emacs\...

The key insight here is keeping everything within the Emacs installation directory. This makes the whole setup portable—you can copy it to another machine or keep it on a USB drive.

Step 1: Installing Emacs

Download Emacs 30.1 from the GNU Emacs download page. For Windows, grab the installer or the zip archive.

I install to an external drive D:\source\emacs-30.1 rather than Program Files—it avoids permission issues and keeps everything in one place.

Test your installation by running bin\runemacs.exe. You should see a fresh Emacs frame.

Step 2: Setting Up csharp-ls (The C# Language Server)

This is the heart of the C# development experience. csharp-ls provides code completion, go-to-definition, find references, diagnostics, and more through the Language Server Protocol (LSP).

Option A: Installing via dotnet tool (Recommended for Internet Access)

If you have internet access, the easiest way to install csharp-ls is as a .NET global tool:

# Install the latest version globally
dotnet tool install --global csharp-ls

# Or install a specific version
dotnet tool install --global csharp-ls --version 0.20.0

# Verify installation
csharp-ls --version

By default, global tools are installed to:

Windows: %USERPROFILE%\.dotnet\tools

The executable will be csharp-ls.exe and can be called directly once the tools directory is in your PATH.

Option B: Offline Installation via NuGet Package

For air-gapped environments, you can download the NuGet package and extract it manually:

On a machine with internet, download the package:

 # Download the nupkg file
 nuget install csharp-ls -Version 0.20.0 -OutputDirectory ./packages

 # Or download directly from NuGet Gallery:
 # https://www.nuget.org/packages/csharp-ls/
 # Click "Download package" on the right side

The .nupkg file is just a ZIP archive. Extract it:

 # Rename to .zip and extract, or use 7-Zip
 # The DLLs are in tools/net9.0/any/

Copy the tools/net9.0/any/ directory to your Emacs bin:

 xcopy /E packages\csharp-ls.0.20.0\tools\net9.0\any D:\source\emacs-30.1\bin\csharp-ls\

The language server is now at: D:\source\emacs-30.1\bin\csharp-ls\CSharpLanguageServer.dll

Configuring Eglot for csharp-ls

In your init.el, configure Eglot to use csharp-ls:

(require 'eglot)

;; Option A: If installed as a global tool
(setq eglot-server-programs
 '((csharp-mode . ("csharp-ls"))))

;; Option B: If running from extracted DLL
(setq eglot-server-programs
 '((csharp-mode . ("dotnet"
 "D:/source/emacs-30.1/bin/csharp-ls/CSharpLanguageServer.dll"))))

I also have the following commented out if there are some eglot functions that causes slowdowns or I just think I don’t need:

(setq eglot-ignored-server-capabilities
 '(
 ;; :hoverProvider ; Documentation on hover
 ;; :completionProvider ; Code completion
 ;; :signatureHelpProvider ; Function signature help
 ;; :definitionProvider ; Go to definition
 ;; :typeDefinitionProvider ; Go to type definition
 ;; :implementationProvider ; Go to implementation
 ;; :declarationProvider ; Go to declaration
 ;; :referencesProvider ; Find references
 ;; :documentHighlightProvider ; Highlight symbols automatically
 ;; :documentSymbolProvider ; List symbols in buffer
 ;; :workspaceSymbolProvider ; List symbols in workspace
 ;; :codeActionProvider ; Execute code actions
 ;; :codeLensProvider ; Code lens
 ;; :documentFormattingProvider ; Format buffer
 ;; :documentRangeFormattingProvider ; Format portion of buffer
 ;; :documentOnTypeFormattingProvider ; On-type formatting
 ;; :renameProvider ; Rename symbol
 ;; :documentLinkProvider ; Highlight links in document
 ;; :colorProvider ; Decorate color references
 ;; :foldingRangeProvider ; Fold regions of buffer
 ;; :executeCommandProvider ; Execute custom commands
 ;; :inlayHintProvider ; Inlay hints
 ))

Step 3: Setting Up the Debugger (netcoredbg)

For debugging .NET applications, we’ll use netcoredbg, which implements the Debug Adapter Protocol (DAP).

Installing netcoredbg

Download from Samsung’s GitHub releases
Extract to D:\source\emacs-30.1\bin\netcoredbg\
Verify: netcoredbg.exe --version

Configuring dape for Debugging

dape is an excellent DAP client for Emacs. Here’s my configuration:

(use-package dape
 :load-path "z:/SharedVM/source/dape-master"
 :init
 ;; Set key prefix BEFORE loading dape
 (setq dape-key-prefix (kbd "C-c d"))
 :config
 ;; Define common configuration
 (defvar project-netcoredbg-path "d:/source/emacs-30.1/bin/netcoredbg/netcoredbg.exe"
 "Path to netcoredbg executable.")
 (defvar project-netcoredbg-log "d:/source/emacs-30.1/bin/netcoredbg/netcoredbg.log"
 "Path to netcoredbg log file.")
 (defvar project-project-root "d:/source/PROJECT"
 "Root directory of PROJECT project.")
 (defvar project-build-config "Debug"
 "Build configuration (Debug or Release).")
 (defvar project-target-arch "x64"
 "Target architecture (x64, x86, or AnyCPU).")

 ;; Helper function to create component configs
 (defun project-dape-config (component-name dll-name &optional stop-at-entry)
 "Create a dape configuration for a component.
COMPONENT-NAME is the component directory name
DLL-NAME is the DLL filename without extension.
STOP-AT-ENTRY if non-nil, stops at program entry point."
 (let* ((component-dir (format "%s/%s" project-project-root component-name))
 (bin-path (format "%s/bin/%s/%s/net9.0"
 component-dir
 project-target-arch
 project-build-config))
 (dll-path (format "%s/%s.dll" bin-path dll-name))
 (config-name (intern (format "netcoredbg-launch-%s"
 (downcase component-name)))))
 `(,config-name
 modes (csharp-mode csharp-ts-mode)
 command ,project-netcoredbg-path
 command-args (,(format "--interpreter=vscode")
 ,(format "--engineLogging=%s" project-netcoredbg-log))
 normalize-path-separator 'windows
 :type "coreclr"
 :request "launch"
 :program ,dll-path
 :cwd ,component-dir
 :console "externalTerminal"
 :internalConsoleOptions "neverOpen"
 :suppressJITOptimizations t
 :requireExactSource nil
 :justMyCode t
 :stopAtEntry ,(if stop-at-entry t :json-false))))

 ;; Register all component configurations
 (dolist (config (list
 (project-dape-config "DM" "DM.MSS" t)
 (project-dape-config "Demo" "Demo.MSS" t)
 (project-dape-config "Test_001" "Test" t)))
 (add-to-list 'dape-configs config))

 ;; Set buffer arrangement and other options
 (setq dape-buffer-window-arrangement 'gud)
 (setq dape-debug t)
 (setq dape-repl-echo-shell-output t))

Now you can start debugging with M-x dape and selecting your configuration.

Step 4: Installing Supporting Tools

Portable Git

Download PortableGit-2.50.0-64-bit.7z.exe from git-scm.com
Run and extract to D:\source\emacs-30.1\bin\PortableGit\

This gives you git.exe, bash.exe, and a whole Unix-like environment.

ripgrep (Fast Searching)

Download from ripgrep releases
Extract rg.exe to D:\source\emacs-30.1\bin\find\

ripgrep is dramatically faster than grep for searching codebases.

Hunspell (Spell Checking)

Download hunspell-1.3.2-3-w32-bin.zip
Extract to D:\source\emacs-30.1\bin\hunspell\
Download dictionary files (en_GB.dic and en_GB.aff) and place in hunspell\share\hunspell\

ImageMagick (Image Processing)

Download the portable Q16 x64 version from imagemagick.org
Extract to D:\source\emacs-30.1\bin\ImageMagick-7.1.2-9-portable-Q16-x64\

This enables image-dired thumbnail generation.

FFmpeg (Video Processing)

Download from ffmpeg.org (essentials build is fine)
Extract to D:\source\emacs-30.1\bin\ffmpeg-7.1.1-essentials_build\

Useful for video thumbnails in dired and media processing.

Step 5: Configuring the PATH

This is crucial—Emacs needs to find all these tools. Here’s the PATH configuration from my init.el:

(when (eq system-type 'windows-nt)
 (let* ((emacs-bin "d:/source/emacs-30.1/bin")
 (xPaths
 `(,emacs-bin
 ,(concat emacs-bin "/PortableGit/bin")
 ,(concat emacs-bin "/PortableGit/usr/bin")
 ,(concat emacs-bin "/hunspell/bin")
 ,(concat emacs-bin "/find")
 ,(concat emacs-bin "/netcoredbg")
 ,(concat emacs-bin "/csharp-ls/tools/net9.0/any")
 ,(concat emacs-bin "/ffmpeg-7.1.1-essentials_build/bin")
 ,(concat emacs-bin "/ImageMagick-7.1.2-9-portable-Q16-x64")))
 (winPaths (getenv "PATH")))
 (setenv "PATH" (concat (mapconcat 'identity xPaths ";") ";" winPaths))
 (setq exec-path (append xPaths (parse-colon-path winPaths)))))

Step 6: Installing Emacs Packages

Extract these to a shared location or download from MELPA

Package	Purpose
corfu	Modern completion UI
dape	Debug Adapter Protocol client
highlight-indent-guides	Visual indentation guides
ztree	Directory tree comparison
web-mode	Web template editing

Example package configuration:

(use-package corfu
 :load-path "z:/SharedVM/source/corfu-main"
 :custom
 (corfu-auto nil) ; Manual completion trigger
 (corfu-cycle t) ; Cycle through candidates
 (corfu-preselect 'first))

(use-package ztree
 :load-path "z:/SharedVM/source/ztree"
 :config
 (setq ztree-diff-filter-list
 '("build" "\\.dll" "\\.git" "bin" "obj"))
 (global-set-key (kbd "C-c z d") 'ztree-diff))

(use-package web-mode
 :load-path "z:/SharedVM/source/web-mode-master"
 :mode "\\.cshtml?\\'"
 :hook (html-mode . web-mode)
 :bind (:map web-mode-map ("M-;" . nil)))

Note that I turn off autocomplete for corfu and complete using complete-symbol manually, otherwise the LSP is constantly accessed with slowdown.

I often use Meld but am currently am looking to adapt ztree to perform better for directory comparisons.

Web-mode is the best package I have found for html type file navigation and folding, very useful when developing Razor pages for example.

Step 7: auto open file modes

Of course running and building in windows means in Emacs probably having to open .csproj files from time to time, well nxml-mode comes in useful for this:

(add-to-list 'auto-mode-alist '("\\.csproj\\'" . nxml-mode))

Step 8: build script

Here is my general build script, leveraging msbuild and running generally from eshell

New projects are added to :

set PROJECTS
set PROJECT_NAMES

@echo off
setlocal

REM =================================================================
REM Build Management Script
REM =================================================================
REM Usage: build-selected.bat [action] [verbosity] [configuration] [platform]
REM action: build, clean, restore, rebuild (default: build)
REM verbosity: quiet, minimal, normal, detailed, diagnostic (default: minimal)
REM configuration: Debug, Release (default: Debug)
REM platform: x64, x86, "Any CPU" (default: x64)
REM =================================================================

REM Set defaults
set ACTION=%1
set VERBOSITY=%2
set CONFIGURATION=%3
set PLATFORM=%4

if "%ACTION%"=="" set ACTION=build
if "%VERBOSITY%"=="" set VERBOSITY=minimal
if "%CONFIGURATION%"=="" set CONFIGURATION=Debug
if "%PLATFORM%"=="" set PLATFORM=x64

echo Build Script - Action=%ACTION%, Verbosity=%VERBOSITY%, Config=%CONFIGURATION%, Platform=%PLATFORM%
echo.

REM Common build parameters
set BUILD_PARAMS=/p:Configuration=%CONFIGURATION% /p:Platform="%PLATFORM%" /verbosity:%VERBOSITY%

REM Set MSBuild target based on action
if /I "%ACTION%"=="build" set TARGET=Build
if /I "%ACTION%"=="clean" set TARGET=Clean
if /I "%ACTION%"=="restore" set TARGET=Restore
if /I "%ACTION%"=="rebuild" set TARGET=Rebuild

if "%TARGET%"=="" (
 echo Error: Invalid action '%ACTION%'. Use: build, clean, restore, or rebuild
 exit /b 1
)

echo Executing %ACTION% action...
echo.

set PROJECTS[1]=Demo/Demo.csproj
set PROJECT_NAMES[1]=Demo

set PROJECTS[2]=Test/Test.csproj
set PROJECT_NAMES[2]=Test

set PROJECT_COUNT=2

REM Special handling for rebuild (clean then build)
if /I "%ACTION%"=="rebuild" (
 echo === CLEANING PHASE ===
 for /L %%i in (1,1,%PROJECT_COUNT%) do (
 call :process_project %%i Clean
 if errorlevel 1 goto :error
 )
 echo.
 echo === BUILDING PHASE ===
 set TARGET=Build
)

REM Process all active projects
for /L %%i in (1,1,%PROJECT_COUNT%) do (
 call :process_project %%i %TARGET%
 if errorlevel 1 goto :error
)

echo.
if /I "%ACTION%"=="clean" (
 echo All selected components cleaned successfully!
) else if /I "%ACTION%"=="restore" (
 echo All selected components restored successfully!
) else if /I "%ACTION%"=="rebuild" (
 echo All selected components rebuilt successfully!
) else (
 echo All selected components built successfully!
)
goto :end

:process_project
 setlocal EnableDelayedExpansion
 set idx=%1
 set target=%2

 REM Get project path and name using the index
 for /f "tokens=2 delims==" %%a in ('set PROJECTS[%idx%] 2^>nul') do set PROJECT_PATH=%%a
 for /f "tokens=2 delims==" %%a in ('set PROJECT_NAMES[%idx%] 2^>nul') do set PROJECT_NAME=%%a

 if "!PROJECT_PATH!"=="" goto :eof

 echo ----------------------------------------
 echo [%idx%/%PROJECT_COUNT%] %target%ing !PROJECT_NAME!...

 REM Build the project normally
 msbuild "!PROJECT_PATH!" /t:%target% %BUILD_PARAMS%
 if errorlevel 1 exit /b 1

goto :eof

:error
echo.
echo %ACTION% failed! Check the output above for errors.
exit /b 1

:end
echo %ACTION% completed at %time%

to launch applications of course, if it is a pure DOTNET project you would use dotnet run

Troubleshooting

“Cannot find csharp-ls” or Eglot won’t start

Check the PATH: M-x getenv RET PATH
Verify the DLL exists at the configured location
Try running manually: dotnet path\to\CSharpLanguageServer.dll --version
Check *eglot-events* buffer for detailed error messages

LSP is slow or uses too much memory

Try adding to your configuration:

;; Increase garbage collection threshold during LSP operations
(setq gc-cons-threshold 100000000) ; 100MB
(setq read-process-output-max (* 1024 1024)) ; 1MB

Debugger won’t attach

Ensure the project is built in Debug configuration
Check the DLL path matches your build output
Look at *dape-repl* for error messages
Verify netcoredbg runs: netcoredbg.exe --version

Conclusion

This setup has served me well for my windows .NET 9.0 projects and various other C# work. The key benefits:

Portability: Everything lives in one directory
Speed: csharp-ls is notably faster than OmniSharp
Flexibility: Easy to customise and extend
Offline-capable: Works in air-gapped environments

The initial setup takes some effort, but once it’s done, you have a powerful, consistent development environment that travels with you.

Expanding Ollama Buddy: Mistral Codestral Integration

James Dyer — Thu, 11 Dec 2025 08:19:00 +0000

Ollama Buddy now supports Mistral’s Codestral - a powerful code-generation model from Mistral AI that seamlessly integrates into the ollama-buddy ecosystem.

https://github.com/captainflasmr/ollama-buddy

https://melpa.org/#/ollama-buddy

So now we have:

Local Ollama models — full control, complete privacy
OpenAI — extensive model options and API maturity
Claude — reasoning and complex analysis
Gemini — multimodal capabilities
Grok — advanced reasoning models
Codestral — specialized code generation NEW

To get up and running…

First, sign up at Mistral AI and generate an API key from your dashboard.

Add this to your Emacs configuration:

(use-package ollama-buddy
 :bind
 ("C-c o" . ollama-buddy-menu)
 ("C-c O" . ollama-buddy-transient-menu-wrapper)
 :custom
 (ollama-buddy-codestral-api-key
 (auth-source-pick-first-password :host "ollama-buddy-codestral" :user "apikey"))
 :config
 (require 'ollama-buddy-codestral nil t))

Once configured, Codestral models will appear in your model list with an s: prefix (e.g., s:codestral-latest). You can:

Select it from the model menu (C-c m)
Use it with any command that supports model selection
Switch between local and cloud models on-the-fly

Convert copied jira kanban to org (jira-to-org)

James Dyer — Fri, 28 Nov 2025 14:56:00 +0000

I have been fiddling around with some very rudimentary Jira integration to org, basically something very simple, just a regular copy from the kanban and then convert into org headlines!

This package is designed for simpler workflows where you copy data from Jira rather than maintaining API integration.

Here is a link to the package:

https://github.com/captainflasmr/jira-to-org

Overview

jira-to-org is an Emacs package that converts Jira sprint board data into org-mode task entries. It parses text copied directly from Jira sprint boards and transforms it into properly formatted org-mode headings with TODO keywords, priorities, tags, and metadata.

Features

Parse Jira sprint data from buffers, regions, or clipboard
Convert Jira statuses to org-mode TODO keywords
Map Jira priorities to org-mode priorities (A/B/C)
Generate tags from assignees, sprint identifiers, and years
Update existing org entries based on fresh Jira data
Customizable mappings for assignees, priorities, and statuses
Configurable heading levels and default values

Installation

Manual Installation

Download jira-to-org.el to your Emacs configuration directory
Add to your init.el:

(add-to-list 'load-path "/path/to/jira-to-org/")
(require 'jira-to-org)

Using `use-package`

(use-package jira-to-org
 :load-path "/path/to/jira-to-org/"
 :custom
 (jira-to-org-default-sprint "s7")
 (jira-to-org-default-year "2025")
 (jira-to-org-heading-level 4))

Usage

Basic Workflow

Open your Jira sprint board in a web browser
Select and copy the sprint data (the entire board or specific columns)
In Emacs, use one of the parsing commands

Commands

`jira-to-org-parse-buffer`

Parse the entire current buffer as Jira data. The result is copied to the kill ring.

M-x jira-to-org-parse-buffer

With prefix argument (C-u), prompts for a sprint tag:

C-u M-x jira-to-org-parse-buffer
Sprint tag (e.g., s7): s8

`jira-to-org-parse-region`

Parse Jira data in the selected region. The result is copied to the kill ring.

1. Select region containing Jira data
2. M-x jira-to-org-parse-region

`jira-to-org-parse-and-insert`

Parse Jira data from the clipboard and insert the org headings at point.

1. Copy Jira data to clipboard
2. Position cursor where you want entries inserted
3. M-x jira-to-org-parse-and-insert

`jira-to-org-update-from-jira`

Update existing org entries based on fresh Jira data. This command:

Updates TODO statuses for entries that already exist in your buffer
Reports how many entries were updated
Copies new items (not found in buffer) to the kill ring

M-x jira-to-org-update-from-jira

Example Input Format

The package expects text copied from Jira sprint boards in this format:

To Do
MM-78
Implement IG connection management APIs
Assignee: James Dyer
Priority: Medium
Issue Type: Story
2

In Progress
MM-79
Create gRPC service definition
Assignee: Freddy
Priority: High
3

Done
MM-75
Setup project structure
Assignee: N Cropper
Priority: Low
Issue Type: Task
1

Example Output

The above input would be converted to:

#+BEGIN_EXAMPLE

TODO MM-78 Implement IG connection management APIs

DOING MM-79 Create gRPC service definition

DONE MM-75 Setup project structure

#+END_EXAMPLE

Configuration

Customization Variables

`jira-to-org-default-sprint`

Default sprint tag to add to all entries (e.g., "s7"). If nil, no sprint tag is added.

(setq jira-to-org-default-sprint "s7")

`jira-to-org-default-year`

Default year to add as a tag to all entries.

(setq jira-to-org-default-year "2025")

`jira-to-org-assignee-map`

Alist mapping full names (as they appear in Jira) to short tag names.

(setq jira-to-org-assignee-map
 '(("James Dyer" . "jdyer")
 ("Freddy" . "freddy")
 ("N Cropper" . "ncropper")))

`jira-to-org-priority-map`

Alist mapping Jira priority levels to org-mode priority letters.

(setq jira-to-org-priority-map
 '(("Highest" . "A")
 ("High" . "A")
 ("Medium" . "B")
 ("Low" . "C")
 ("Lowest" . "C")))

`jira-to-org-status-map`

Alist mapping Jira status names to org-mode TODO keywords.

(setq jira-to-org-status-map
 '(("To Do" . "TODO")
 ("In Progress" . "DOING")
 ("Done" . "DONE")))

`jira-to-org-heading-level`

Number of asterisks for generated org headings (default: 4).

(setq jira-to-org-heading-level 3) ; Use *** instead of ****

Complete Configuration Example

(use-package jira-to-org
 :custom
 (jira-to-org-default-sprint "s8")
 (jira-to-org-default-year "2025")
 (jira-to-org-heading-level 4)
 (jira-to-org-assignee-map
 '(("James Dyer" . "jdyer")
 ("Freddy Johnson" . "freddy")
 ("Sarah Chen" . "schen")
 ("Mike Wilson" . "mwilson")))
 (jira-to-org-priority-map
 '(("Highest" . "A")
 ("High" . "A")
 ("Medium" . "B")
 ("Low" . "C")
 ("Lowest" . "C")))
 (jira-to-org-status-map
 '(("To Do" . "TODO")
 ("In Progress" . "DOING")
 ("In Review" . "REVIEW")
 ("Done" . "DONE")))
 :bind
 (:map org-mode-map
 ("C-c j p" . jira-to-org-parse-and-insert)
 ("C-c j u" . jira-to-org-update-from-jira)))

Workflow Integration

Sprint Planning Workflow

Open your sprint planning org file
Navigate to the sprint section
Copy the Jira sprint board data
Run M-x jira-to-org-parse-and-insert
Adjust any entries as needed

Daily Standup Updates

Copy current sprint board state from Jira
Run M-x jira-to-org-update-from-jira
Review updated TODO states
Any new items are copied to kill ring for manual placement

Custom Key Bindings

;; Add to your org-mode configuration
(with-eval-after-load 'org
 (define-key org-mode-map (kbd "C-c j p") #'jira-to-org-parse-and-insert)
 (define-key org-mode-map (kbd "C-c j r") #'jira-to-org-parse-region)
 (define-key org-mode-map (kbd "C-c j b") #'jira-to-org-parse-buffer)
 (define-key org-mode-map (kbd "C-c j u") #'jira-to-org-update-from-jira))

Parsed Fields

The package extracts and uses the following fields from Jira data:

Jira Field	Usage	Example
Issue Key	Included in heading	MM-78
Title	Included in heading	Fix bug in API
Status	Converted to TODO keyword	In Progress
Assignee	Converted to tag	James Dyer
Priority	Converted to org priority	Medium
Story Points	Extracted (not currently used in output)	3

Customizing for Your Organization

Adjusting Issue Key Pattern

If your Jira instance uses a different project key pattern, modify the regex in jira-to-org--parse-buffer-to-items:

;; Current pattern matches MM-123
((string-match "^\\(MM-[0-9]+\\)$" line)

;; Example: Match PROJECT-123
((string-match "^\\(PROJECT-[0-9]+\\)$" line)

;; Example: Match multiple projects (PROJ1-123 or PROJ2-123)
((string-match "^\\(\\(?:PROJ1\\|PROJ2\\)-[0-9]+\\)$" line)

Adding Custom Status Mappings

If your Jira workflow has additional statuses:

(setq jira-to-org-status-map
 '(("To Do" . "TODO")
 ("In Progress" . "DOING")
 ("Code Review" . "REVIEW")
 ("QA Testing" . "TESTING")
 ("Blocked" . "BLOCKED")
 ("Done" . "DONE")))

Make sure your org-mode TODO keywords match:

(setq org-todo-keywords
 '((sequence "TODO" "DOING" "REVIEW" "TESTING" "BLOCKED" "|" "DONE")))

Troubleshooting

No Items Parsed

Verify the Jira data format matches the expected structure
Check that issue keys match the pattern (e.g., MM-123)
Ensure status headers (To Do, In Progress, Done) are present

Wrong Assignee Tags

Check jira-to-org-assignee-map contains mappings for all team members
Verify exact spelling of names in Jira matches the mapping

Incorrect TODO Keywords

Verify jira-to-org-status-map maps all statuses used in your Jira
Check that target TODO keywords exist in org-todo-keywords

Entries Not Found During Update

Ensure issue keys in org file exactly match Jira format
Verify the heading contains the issue key followed by a space

API Functions

For programmatic use:

`jira-to-org-parse-string`

(jira-to-org-parse-string STRING &optional SPRINT)

Parse STRING containing Jira data and return org-mode headings as a string.

`jira-to-org--parse-buffer-to-items`

(jira-to-org--parse-buffer-to-items BUFFER-OR-STRING)

Parse Jira data into a list of jira-to-org-item structs for further processing.

`jira-to-org--item-to-org-heading`

(jira-to-org--item-to-org-heading ITEM &optional SPRINT)

Convert a jira-to-org-item struct to an org-mode heading string.

Contributing

Contributions are welcome! Please submit issues or pull requests on the project repository.

Development Setup

Clone the repository
Load jira-to-org.el in Emacs
Make changes and test with sample Jira data
Run byte-compilation: M-x byte-compile-file

Testing

Create a test file with sample Jira data and verify parsing:

(with-temp-buffer
 (insert "To Do\nMM-1\nTest Issue\nAssignee: Test User\nPriority: High\n")
 (jira-to-org-parse-buffer))

License

This package is provided as-is for personal and professional use.

Changelog

Version 1.0

Initial release
Basic parsing of Jira sprint data
Configurable mappings for assignees, priorities, and statuses
Buffer, region, and clipboard parsing commands
Update existing entries from fresh Jira data

org-jira - Full bidirectional sync with Jira (requires API access)
jiralib2 - Jira REST API library for Emacs
org-jira (baohaojun) - Alternative Jira integration

The Ping Localhost Hack for Emacs Shell on Windows

James Dyer — Sat, 01 Nov 2025 15:24:00 +0000

For a little while now, I’ve been developing software that needs to run on Windows (I know, I know!) and occasionally firing up batch scripts from within Emacs shell. Everything was working perfectly until I needed to add a simple delay between commands. That’s when I discovered one of Windows batch scripting’s more peculiar quirks.

The obvious solution for adding a delay in a Windows batch script is the timeout command:

timeout /T 5

Simple enough, right? Well, it turns out that when you run this from Emacs shell (or any non-interactive environment), it just… doesn’t work. The script either hangs indefinitely or skips the timeout entirely. Even adding the /NOBREAK flag doesn’t reliably solve the issue.

The timeout command is actually an interactive program that expects to interact with a proper Windows console. It’s designed to wait for user input OR timeout, whichever comes first. When running from Emacs shell:

There’s no proper console attachment that timeout can latch onto
Input redirection gets confused
The TTY limitations of Emacs shell mean timeout can’t find what it’s looking for

This is particularly frustrating when you’ve got a perfectly good batch script that works fine from cmd.exe but fails spectacularly when launched from your beloved Emacs environment.

Here’s where things get interesting (and slightly ridiculous). The solution that the Windows community by all accounts has rallied around is the ping command:

ping 127.0.0.1 -n 6 > nul

So here we are using a network diagnostic tool as a timer. But it works brilliantly! Here’s why:

ping is completely non-interactive - it just runs and exits
Each ping takes roughly 1 second by default
The -n flag specifies the number of pings, so -n 6 gives you approximately 5 seconds (n-1)
It’s available on every Windows system, no exceptions
It doesn’t care about console attachment, TTY setup, or any of that nonsense

In my batch scripts that launch from Emacs, I’ve settled on this pattern:

@echo off
echo Starting process...
ping 127.0.0.1 -n 3 > nul
echo Continuing after 2 second delay...

The > nul redirects all the ping output to nowhere, so you don’t see the typical ping response spam in your output. Clean, simple, and most importantly - it actually works!

This whole situation is a perfect example of the kind of head-scratching workarounds you encounter when working across different environments. Emacs shell on Windows is already operating in a slightly weird space - it’s not quite a native Windows console, not quite a Unix-like shell, but something in between.

After adding this to my batch scripts, everything now runs smoothly from Emacs shell on Windows. The software launches, pauses where it needs to, and continues without any console-related tantrums.

Is it elegant? Not particularly. Is it a proper use of the ping command? Absolutely not. Does it work perfectly every single time? You bet it does!

And really, isn’t that the most important thing? Sometimes the best solution isn’t the most theoretically pure one - it’s the one that just works, regardless of how strange it might look to an outsider.

Planning my Weekly Meals in Emacs!

James Dyer — Fri, 26 Sep 2025 10:05:00 +0100

And what have I been working on recently?, well lets consider the following questions…

What should we eat Monday through Friday?
What about the weekend when we have more time to cook?
Didn’t we just have pasta last week? And the week before?
How do I plan for batch cooking without ending up with the same meal rotation?
Where did I put that list of meal ideas again?

And what has all this to do with Emacs I hear to you say?, well as some of you might have guessed I thought I would let Emacs take the stress out of these types of decisions by writing a very simple meal planning package and instead of trying to be everything to everyone I have just decided to focus it on solving one specific problem: generating varied weekly meal plans that support batch cooking workflows.

Here is a link to the package : https://github.com/captainflasmr/meal-planner

Here’s how it works:

Your meals are stored in simple text files, one meal per line:

Chicken curry
Pizza
Lasagna
Toad in the hole
Chilli con carne
Sausage bake
Pasta bake

and one file per category (which I shall explain later)

weekday-dinner.txt
weekday-lunch.txt
weekday-pudding.txt
weekday-sweet.txt
weekend-dessert.txt
weekend-dinner.txt
weekend-lunch.txt

Need to add a new meal? Just edit the text file. Want to remove something you’re tired of? delete the line and who knows, maybe for fun, add these files to your favourite Emacs LLM integration, gptel of course or my personal favourite (as I wrote it) https://github.com/captainflasmr/ollama-buddy and see what myriad of fantastical foods it can add!

I have simplified the whole concept as much as possible, so instead of planning individual meals for each day (which gets repetitive and tiresome), it recognizes that many of us batch cook, so:

Weekdays (Monday-Friday): One set of meals for the entire week
Weekend (Saturday-Sunday): A different set of meals for more relaxed cooking and possibly straight from the freezer!

When you run M-x meal-planner-generate-week, you will get something like:

=== MEAL PLAN - Week 42 ===

WEEKDAYS (Monday-Friday):
 Weekday lunch: Chicken curry batch
 Weekday sweet: Apple slices
 Weekday dinner: Pasta bake
 Weekday pudding: Jam sponge

WEEKEND (Saturday-Sunday):
 Weekend lunch: Omelette
 Weekend dinner: Beef stew
 Weekend dessert: Eton mess

Also the package automatically tracks what you’ve eaten in recent weeks and avoids suggesting the same combinations. No more “didn’t we just have this last week?” moments.

The package supports different types of meals to match my current real-world eating patterns:

Weekday Categories:

Lunch meals (lunchbox-friendly)
Sweet snacks/desserts
Main dinner meals
Evening puddings/desserts

Weekend Categories:

Leisurely lunch meals
Weekend dinner meals
Weekend desserts

Here’s how meal-planner.el fits into our weekly routine:

Sunday Morning: Run M-x meal-planner-generate-week while having coffee. The package suggests a week’s worth of meals, carefully avoiding anything we’ve had recently.

Sunday Afternoon: Use M-x meal-planner-edit-category to quickly add any new meal ideas we’ve discovered, or remove things we’re temporarily tired of.

Shopping: The meal plan gives us a clear shopping list foundation for when we do our weekly online order.

Weekday Evenings: No decisions needed! We already know what we’re having, and the ingredients are ready to go!

Installation is straightforward:

;; Add to your init.el
(require 'meal-planner)

Then run the setup command to create sample meal files:

M-x meal-planner-setup-data-files

This creates a ~/.emacs.d/meal-data/ directory with sample meals for each category. Edit these files to match your preferences, then generate your first meal plan:

M-x meal-planner-generate-week

This package embodies one aspect I love about Emacs, taking a real-world problem and solving it in an elegant, customizable way. Now my brain has a little more space to accommodate more Emacs rabbit holes!

Debugging Software Breakage with Git Stash and Emacs

James Dyer — Wed, 10 Sep 2025 08:00:00 +0100

We’ve all been there, your code was working perfectly from a clean checkout, but after making a bunch of changes across multiple files, something has broken. The dreaded question arises! which change caused the break? This is the story of how a debugging session led me to discover gaps in Emacs’ VC mode and ultimately create a custom solution.

I started with a clean, working codebase. After implementing several features across different files, my software suddenly stopped working. The classic debugging nightmare, multiple changes, one (or more) breaking changes, and no clear path to the culprit.

My debugging strategy as always is methodical. Over many years of software engineering I have learnt that you just need to figure out a systematic approach and then just get on with it!

Start from the known-good base version
Gradually reintroduce changes from my working set
Test after each addition to identify the breaking point

Git stash turned out to be perfect for this workflow. Firstly I stashed all my changes, giving me a clean working directory to start from. My plan was to selectively apply portions of the stash, testing after each addition.

Using Emacs’ built-in VC mode, I could use vc-git-stash-show to display my stashed changes in a diff buffer. From there, I could navigate through the files and selectively apply hunks using Emacs’ diff mode commands. This gave me fine-grained control over which changes to reintroduce.

As I progressed through applying changes, I realised that I would really like to keep an eye on what changes remained in my stash compared to my current working directory, basically like a dynamic diff to be regenerated after each application (like typically on an individual file using ediff). This would allow me to keep an eye on likely culprits as I move through the hunking process.

In pure Git, this is straightforward:

git diff stash@{0}

But Emacs’ VC mode doesn’t provide a command for this specific operation (I have found this not to be uncommon for Emacs vc-mode, but I still like it anyways!)

Generally I think, Emacs’ VC interface is designed to be VCS agnostic, which is both a strength and a limitation. While it provides excellent abstractions for common operations like vc-diff, it doesn’t expose Git specific features like comparing against stash references.

The available VC commands were:

vc-diff - compares working directory with HEAD or between revisions
vc-git-stash-show - shows the diff of a stash

But no “diff working directory against stash” command

Now, it’s worth noting that Magit, does apparently provide this functionality, but I prefer to run on air-gapped systems (yes, that again!) where installing external packages isn’t always practical or desired. In such environments, I lean heavily on Emacs’ built-in functionality and augment it with custom elisp when needed which is probably something I suspect I am likely to do in this case.

I had an initial eshell idea on how to accomplish this!, for example you can redirect command line output to Emacs buffers using the #<buffer name> syntax, so lets try that!

I tried:

git diff stash@{0} > #<buffer *git-diff*> && diff-mode

This almost worked, but I encountered a timer error related to eshell’s command chaining.

and then I tried:

git diff stash@{0} > #<buffer *git-stash-diff*> ; diff-mode

After some experimentation, I still couldn’t quite get eshell to generate a buffer from a command and then initiate a mode. Of course I could just jump to the buffer and run it myself, but generally I wanted a solution to be easily repeatable.

Right, lets scrap the eshell idea and lets fall back on my tried and tested method of writing a defun in elisp!:

(defun my-git-diff-stash (stash-ref)
 "Diff working directory against specified stash"
 (interactive "sStash reference (e.g., 0, 1, 2): ")
 (let ((buffer (get-buffer-create "*git-stash-diff*")))
 (with-current-buffer buffer
 (erase-buffer)
 (call-process "git" nil buffer t "diff" (format "stash@{%s}" stash-ref))
 (diff-mode)
 (goto-char (point-min)))
 (switch-to-buffer buffer)))

This function:

Prompts for a stash reference (defaulting to numeric input like 0, 1, 2)
Creates a dedicated buffer for the diff
Runs git diff against the specified stash
Automatically applies diff-mode for syntax highlighting
Opens the buffer and positions the cursor at the beginning

The final step was to bind this command to the VC prefix map:

(define-key vc-prefix-map (kbd "S") 'my-git-diff-stash)

“S” is currently used for a regex search of some kind which I currently don’t understand and hence am not using.

Now I can use C-x v S to quickly diff my working directory against any stash (although who knows when I will need this again!)

With this in place, my debugging workflow became smoother

Stash all changes
Apply changes incrementally using vc-git-stash-show
Test the software after each addition
When it still works, check what remains C-x v S
Continue applying changes from the remaining diff
When it breaks, I have a good idea of the breaking issue

This experience taught me several valuable lessons:

VC mode’s limitations: While Emacs’ VC interface is excellent for common operations, specialized Git workflows sometimes require custom solutions.
The value of built-in solutions: Working in air-gapped environments has taught me to maximize Emacs’ built-in capabilities before reaching for external packages. While Magit would have solved this problem out of the box, building the solution myself using VC mode and custom elisp keeps dependencies minimal and increases my understanding of both Git and Emacs internals.
Eshell’s power: The ability to redirect command output directly to Emacs buffers is incredibly useful, even if it has some quirks with command chaining and in the end I never really got it to work, but it is in my brain more concretely now as this blog post now exists!
Integration matters: Binding custom functions to standard keymaps makes them feel like native features.

Customizing Emacs Completion: From Fido's Fuzzy Matching to Literal Substring

James Dyer — Fri, 05 Sep 2025 10:06:00 +0100

For my completion framework, I’m currently using fido-mode, and more recently, fido-vertical-mode. However, I’m scratching yet another itch in my ongoing quest to be more efficient in Emacs, specifically to jump to files more quickly. I explored this in a previous post where I enhanced the recentf functionality to work through completing-read in a predictable order, but what about the completing-read interface itself?

This happens to me often in Emacs, there is a subconscious functional annoyance which eventually bubbles to the surface and this case the surface bubble revolves around fido’s fuzzy matching behaviour. Simply put, I don’t like it!

While it can be helpful for discovering files and commands you partially remember, sometimes you know exactly what you’re looking for and want a more literal, predictable search experience, in fact for me now, I would say it is not just sometimes, but always!. The fuzzy matching is finding too many candidates when I type in a few characters and really I want a contiguous input string to be literally matched.

This post chronicles my journey from fido’s flex matching to a custom setup that provides literal substring matching, perfect for when you know what you want and just want to type it directly.

Hang on a sec, can’t I just change the completion style?, this should be easy!

(setq completion-styles '(substring basic))

But that has no effect!, boooo!

Anyways, that was a quick attempt at a fix, in the meantime lets explore flex a little bit more and icomplete (which is the underpinning completion technology of fido) and see if we cam come up with a robust solution.

Fido-mode use what’s called “flex” completion by default. This means that when you type abc, it will match files like a_long_b_filename_c.txt because it finds the letters a, b, and c in that order, even with other characters between them.

While this flexibility is powerful, it can be frustrating when you want to search for a specific substring. If you’re looking for a file named project-abc-config.txt, you might expect typing abc to prioritize that match, but flex matching might show you a_big_collection.txt first instead.

So back to my initial attempt at a fix by setting the completion-styles variable. The substring style matches your input as a contiguous block anywhere within candidates, while basic does prefix matching. This seemed like exactly what I wanted, I just need to find a way to set it and to make it stick.

After some digging into the source code, I found the culprit in icomplete.el. The icomplete--fido-mode-setup function contains the following:

(defun icomplete--fido-mode-setup ()
 "Setup `fido-mode''s minibuffer."
 (when (and icomplete-mode (icomplete-simple-completing-p))
 ;; ... other settings ...
 (setq-local completion-styles '(flex) ; This line forces flex!
 completion-flex-nospace nil
 ;; ... more settings ...
 )))

This function runs every time you enter the minibuffer, forcibly overriding any completion-styles setting you might have configured. This explains why my setq had no effect, fido was resetting it on every use!

Rather than fight fido’s opinionated behaviour, I could instead switch to icomplete-vertical-mode, which provides a similar interface but respects the standard completion configuration.

(icomplete-vertical-mode 1)

;; scroll list rather than rotating
(setq icomplete-scroll t)

;; Make completion case-insensitive
(setq completion-ignore-case t)
(setq read-file-name-completion-ignore-case t)
(setq read-buffer-completion-ignore-case t)

(with-eval-after-load 'icomplete
 (setq completion-styles '(substring basic partial-completion emacs22)))

This gave me the literal substring matching I wanted and I think I have managed to set up everything else to the way fido comes out of the box.

However, there was one more hurdle.

By default, icomplete-vertical-mode requires you to explicitly select a completion before submitting with C-m (Enter) which is a keybinding I had grown accustomed to using in fido. This adds an extra confirmation step that fido-mode doesn’t have. There is a way around this however and that is to adapt to the keybinding C-j which typically is more of a do literal action then exit type of thing, where C-m is more of just a simple Enter/action. I am willing to adapt to this keybinding.

So this works pretty well for me really, but can I not just get completion-styles to stick for fido?, even though I have a solution I really want to see if I can adjust fido’s default functionality.

Well simply I used an advice function to wrap around the original fido setup function and set up the completion-styles local variable after fido has done its thing:

(defun my-fido-completion-styles-advice (&rest _args)
 "Override completion styles after fido setup."
 (when (and fido-mode (icomplete-simple-completing-p))
 (setq-local completion-styles '(substring basic partial-completion))))

(advice-add 'icomplete--fido-mode-setup :after #'my-fido-completion-styles-advice)

Now I have two options for using completion in Emacs the way I want it and now I can find files, or anything else for that matter much more quickly.

This journey taught me several important lessons about Emacs customization:

Read the source: When configuration variables don’t seem to work as expected, the source code often reveals why.
Local vs. global settings: Fido uses setq-local to override settings per-buffer, which is why global setq calls don’t work.
There’s always another way: Emacs’ flexibility means there are usually multiple approaches to achieving the same goal.

While fido-mode’s fuzzy matching is excellent for discovery and exploration, I just wanted the predictability of literal substring matching and with a small advice function, you can have the best of both worlds!

A Better Way to Indent Your Entire Buffer in Emacs?

James Dyer — Tue, 26 Aug 2025 09:56:00 +0100

As an Emacs user, you’ve probably found yourself wanting to clean up the indentation of an entire file. The standard approach is to select all (C-x h) and then run indent-region (I think, correct me if I am wrong!), but this has an annoying side effect: it destroys your current mark position, which might have been carefully set for other operations.

Also, and just whisper it and don’t tell anyone, but I have been using VSCode a little (only for work, of course!) and an indent by default seems to indent the whole file, which initially I thought would be really annoying, but actually it feels quite natural, as always at some point I would like to indent my code.

This is Emacs however and there is a simple solution and I’ve added it to my Emacs configuration:

So, just a recap on some typical workflow, it goes a little something like this:

You’re working in a file with inconsistent indentation
You want to fix the entire buffer’s formatting
You run C-x h (select all) followed by M-x indent-region
Your mark is now at the beginning of the buffer, disrupting your workflow

This is particularly frustrating when you’ve set a mark for a specific editing task and want to preserve that position.

(defun indent-whole-buffer ()
 "Indent the entire buffer without affecting point or mark."
 (interactive)
 (save-excursion
 (save-restriction
 (indent-region (point-min) (point-max)))))

(global-set-key (kbd "C-c i") 'indent-whole-buffer)

The function indents from (point-min) to (point-max), covering the entire buffer, then restores everything to exactly how it was before, except now with proper indentation.

After adding this to your configuration, simply press C-c i (or whatever keybinding you prefer) to indent your entire buffer. Your cursor stays put, your mark remains set, and your file gets beautifully formatted!

Fast Recent File Navigation in Emacs

James Dyer — Sat, 16 Aug 2025 19:07:00 +0100

As an Emacs user, you’re always hunting for ways to shave milliseconds off common tasks and generally noodling around and shaving some more of that yak!. File switching is one of those operations you do hundreds of times a day, so even small improvements compound dramatically. Today, I want to share a workflow that I have been tinkering with that combines the best of Emacs’s built-in recent file tracking with modern completion interfaces.

Emacs gives us several ways out of the box to quickly access files:

find-file
switch-to-buffer for open buffers
Registers
Bookmarks
recentf-mode for recently accessed files

and I have a funny feeling there are probably more.

Each has its place, but they all have limitations. switch-to-buffer only shows currently open buffers, and with fido-mode, I have found that the most frequently used buffers don’t always bubble to the top predictably, I may need to look a little more into this though. Registers are great but require manual setup and only remember the position when you set them, not your last edit location.

What I really wanted was instant access to my recently edited files, with each file opening exactly where I left off!

I thought I had become quite efficient at file switching through fido completion and dired but only recently I realised I was navigating through dired to find files way too often and wasting time. I think this is probably typical of an Emacsers journey and after a while of continuous minor toil there comes a time to take action and shave off those milliseconds and improve flow.

The solution starts by enabling two built-in Emacs features:

(save-place-mode 1)
(recentf-mode 1)
(setq recentf-max-menu-items 10)
(setq recentf-max-saved-items 10)

save-place-mode automatically remembers your cursor position in every file and restores it when you reopen the file, it was the first time I had heard of this when figuring all this out and couldn’t believe I didn’t know about it before (not an uncommon Emacs experience), this works across Emacs sessions, so you get that “pick up exactly where I left off” experience.

And recentf-mode maintains a persistent list of recently visited files, ordered chronologically. Unlike switch-to-buffer, this survives Emacs restarts and gives you a true history of your work and I thought in this case it better to limit the list size as much as possible for greater clarity.

The traditional recentf-open-files command shows a nice ordered list in a buffer but to some it could feel clunky compared to modern completion interfaces. There is also recentf-open which does go through completing read but then reorders the recentf list for some reason, so to me the obvious solution is to push the recent files list through completing-read myself:

(defun my/fido-recentf ()
 "Use fido to select from recently opened files."
 (interactive)
 (completing-read "Recent file: " recentf-list nil t nil 'recentf-list))

To get this to work the way I wanted, I had to supply recentf-list also as the last argument. By using the same symbol for both the collection and the history, we tell the completion system to respect the original ordering. Your most recently accessed files should stay at the top!

In my final solution I have decided to keep the old recentf-open-files interface as an option. Strangely I actually like the old list in a buffer interface so I have included it in my final version as an option.

(defun my/fido-recentf (arg)
 "Use fido to select from recently opened files.
With universal argument, use the traditional recentf-open-files interface."
 (interactive "P")
 (if arg
 (recentf-open-files)
 (find-file (completing-read "Recent file: " recentf-list nil t nil 'recentf-list))))

Now M-x my/fido-recentf gives you completing read, while C-u M-x my/fido-recentf drops you into the classic numbered list.

Bind this to something convenient (I use M-o) and your file navigation transforms! (well that might be a bit of an exaggeration)

This might seem like a small optimization, but it exemplifies what makes Emacs special. We’re not just using the tools as shipped, we’re composing them in novel ways to create something perfectly tailored to our needs.

That’s the kind of workflow improvement that makes every day at the keyboard just a little bit more pleasant, and those small pleasures add up to something significant over months and years of coding.

View-Mode - Emacs's Hidden Modal Editing Gem?

James Dyer — Fri, 01 Aug 2025 08:30:00 +0100

The Rabbit Hole

I’ve fallen down another rabbit hole, but then again, this is Emacs we’re talking about!

In this case it relates to a fundamental editing principle.

I was trying to understand some code, so of course that involved plenty of point/cursor navigation, scrolling, etc. After an hour or so of doing this, I started to wonder if there was a more efficient navigation method involving single keypresses. If I know I only want to view the file, then why not get rid of this modifier key nonsense? 😁 I’m aware that the basic functionality I’m talking about here is modal editing.

There are many different packages out there from boon to meow. So does Emacs have something built-in? Well, throughout my series of blog posts, I often ask this question, and the answer always comes back emphatically the same: “Why yes, of course it does!” This might be a little misleading, as though there isn’t a specific built-in that gives modal editing right out of the box, there is a mode that can be tweaked a little to achieve something similar.

View Mode

So what is the thing that’s been hiding in plain sight? Well, it is view-mode. Although strictly not a modal editing option, I think with a little tweaking I could possibly turn it into one. After a bit of internet stumbling, I came across a Reddit post from someone who has tried something similar. I think I shall add my own spin. The link is https://www.reddit.com/r/emacs/comments/fojc1y/using_viewmode_for_modal_navigation/

If you have been reading my posts over the years, you probably know my general design ethos on such a solution, and that is to use built-in Emacs-centric philosophies and to make sure it can easily be set up on an air-gapped system. Well, for this solution, I’m going to deviate slightly from this idiom and incorporate not just more Emacs-ish keybindings but also some Vim ones! My main reasoning for this is that evil-mode is very popular, and from time to time I have recourse to using Vim over ssh, and the jkhl setup does feel pretty natural.

View-mode has been part of Emacs forever, but its default keybindings feel a bit… antiquated. z and w for scroll up and down? Space for page scroll, Return for forward one line, etc. (Maybe it works in the latter case, as it is more of a legacy Unixy vibe, but really I think we should be using more Emacs-ish keybindings, and as an option, why not Vim ones, as they tend to be mutually exclusive)

The Setup

Of course, view-mode is completely customizable, so here’s my setup that combines the best of both worlds, familiar Emacs patterns and efficient Vim-style navigation:

;; Enable view-mode when entering read-only
(setq view-read-only t)

;; Enhanced keybindings
(with-eval-after-load 'view
 ;; More Emacs-ish keys

 ;; Navigation
 (define-key view-mode-map (kbd "n") 'next-line)
 (define-key view-mode-map (kbd "p") 'previous-line)
 (define-key view-mode-map (kbd "f") 'forward-char)
 (define-key view-mode-map (kbd "b") 'backward-char)

 ;; Beginning/end of line
 (define-key view-mode-map (kbd "a") 'beginning-of-line)
 (define-key view-mode-map (kbd "e") 'end-of-line)

 ;; Vim-ish keys

 ;; Quick exit to edit mode
 (define-key view-mode-map (kbd "i") 'View-exit)
 (define-key view-mode-map (kbd "j") 'next-line)
 (define-key view-mode-map (kbd "k") 'previous-line)
 (define-key view-mode-map (kbd "h") 'backward-char)
 (define-key view-mode-map (kbd "l") 'forward-char)

 ;; Page movement
 (define-key view-mode-map (kbd "u") '(lambda()
 (interactive)
 (View-scroll-page-backward 3)))
 (define-key view-mode-map (kbd "d") '(lambda()
 (interactive)
 (View-scroll-page-forward 3)))

 ;; Beginning/end of line (Vim style)
 (define-key view-mode-map (kbd "0") 'beginning-of-line)
 (define-key view-mode-map (kbd "$") 'end-of-line)

 ;; Beginning/end of buffers
 (define-key view-mode-map (kbd "g") 'beginning-of-buffer)
 (define-key view-mode-map (kbd "G") 'end-of-buffer)

 ;; Other bespoke bindings
 (define-key view-mode-map (kbd ";") 'other-window)

 (define-key view-mode-map (kbd "SPC") 'nil))

;; Quick toggle keys
(global-set-key (kbd "C-<escape>") 'view-mode)
(global-set-key (kbd "C-<tab>") 'view-mode)

;; Optional: return to view-mode after saving
(add-hook 'after-save-hook
 (lambda ()
 (when (and buffer-file-name (not view-mode))
 (view-mode 1))))

;; Visual feedback - box cursor in view mode, bar when editing
(add-hook 'view-mode-hook
 (defun view-mode-hookee+ ()
 (setq cursor-type (if view-mode 'box 'bar))))

Baby Proofing

Here’s where it gets interesting (possibly). I have a baby, and babies have this amazing ability to slam their tiny hands down on keyboards at the most inopportune moments. Nothing quite like a random key smash right in the middle of an important file!. Wouldn’t it be great to have a protective read-only shield over a file? So I decided, why not put all files into view-mode by default?, this way, accidental keypresses won’t modify anything, and I can intentionally switch to edit mode only when I actually need to make changes.

;; Enable view-mode for files by default
(add-hook 'find-file-hook
 (lambda ()
 (unless (or (derived-mode-p 'dired-mode))
 (view-mode 1))))

I’m currently using the automatic activation to see how it goes, but I have to say I’m not completely comfortable with setting files to read-only mode. Although more baby-proof, it does mean I have to activate edit mode (or deactivate view-mode) each time I want to edit a file and that doesn’t feel very Emacsy to me.

Cursor

You will notice that in the setup there is a modification of the cursor depending on the mode state. Although the modeline will indicate if view-mode is on or off, I’m actually quite liking the differentiation in editing modes to be reflected in the cursor. It is simple, and my brain is starting to recognize instinctively which mode I am in with no extra visual baggage.

Subtleties

It is also worth pointing out some more subtleties:

I have added the enabling of view-mode every time a file is saved. I am a habitual saver, I have no idea why (oh wait, habit!), so that means having to enter “edit mode” quite often. We shall see how this goes, but currently it means that I am not having to often flit back to view-mode after some characters are inserted as I would have saved and returned anyway!
In addition, there is a sneaky (setq view-read-only t) which means that toggling a file to and from read-only via C-x C-q will activate view-mode accordingly. I’m not really using this at the moment, but it could come in useful if I start thinking more in a dired manner, where I activate the edit mode in dired quite often to change filenames, so this could be muscle memory transferable. In the main, though, I don’t think setting this is going to hurt anything.
Another subtlety is the lambdas set for the page scroll. view-mode has quite a neat implementation for scrolling, in that, with a prefix or a defun argument, the number of lines for a scroll can be set. I don’t often like to scroll full pages or even half pages, so I typically have set only a few lines for faster scrolling, this of course is configurable to your own tastes.
You can see that I have added in all the basic Emacs and Vim typical navigational keys, and in the case of Emacs, stripped of the modifier. This, for me, feels much more natural, and strangely, I find myself naturally jumping between the Vim and Emacs keys, for shame!
I have already disabled a key within the view-mode mode-map and that is SPC, I found myself often (so far) pressing space without toggling off view-mode and that would scroll one page down - annoying!
If I am using the vim keys often and it might be likely I am viewing files, maybe code files and maybe I have a single horizontal split, I might just like to have a single key to jump back and forward between windows. I chose “;” for a few reasons but the main one is that the key is adjacent to the other vim navigation keys.

It is worth noting, of course, that all normal Emacs navigational keybindings are still available, so you also have that option too within view-mode.

Foibles

So far I have noticed some, lets say, foibles

It is not uncommon that I would want changes that I have just made and saved to be undone, but when undoing I am in view-mode, and the reversal is rejected due to the file being read only!, I might have to think about this one.
In org-mode, with the speed keys enabled which gives you a range of org commands from a single character when the point is at the heading start obviously can cause a conflict. For example, “s” is mapped in speed keys to narrow section, but in view-mode mode it is an incremental search.

Improvements?

One Idea is maybe I can auto-deactivate view-mode when a typical Emacs edit keybinding is detected, but this is fraught with edge cases, but maybe.
Do I go further with a vim paradigm? I’m not going to lie here I like the “x” to delete a character and “dd” to delete a whole line (C-k (kill-line) is something I use all the time). Could I add these in without having to break out of view-mode and hence preserving a flow for fast edits?, not sure.

Conclusion

Anyways, the result is a surprisingly pleasant modal editing experience so far that already feels natural in Emacs while giving me the ergonomic benefits of Vim-style navigation and comfortable single-key navigation options.

Plus, my codebase is now baby-resistant!

Ollama Buddy v1.0: A Simple AI Assistant

James Dyer — Wed, 23 Jul 2025 09:20:00 +0100

After months of development and refinement, I’m excited to announce Ollama Buddy v1.0 - an Emacs package that simply interfaces mainly to ollama, for local LLM usage, but can be integrated to the major online players. This project initially started as a simple integration with Ollama and since then has somewhat evolved into a more fully fully-featured AI Emacs assistant. The main focus with this package is a front facing simplicity but hiding (hopefully) all the features you would expect from an AI chatbot - wait I hate that term, I mean, assistant :). There is also the ability to craft a customizable menu system for different roles.

I had a blast developing this package and next up is RAG!. I saw recently that a package called vecdb was introduced into the package ecosystem to help with the storage of vector embeddings, so as ollama can return embedding vectors for semantic search I thought I would combine my package, vecdb, also probably initially a PostgreSQL database with a pgvector extension and ollama into something that could ingest files directly from Emacs. I think I have figured this out now, I just need to do it (when the baby is asleep, probably!)

Why Choose Ollama Buddy?

I designed Ollama Buddy to be as simple as possible to set up, no backend configuration or complex setup required. This was achievable initially because I focused solely on Ollama integration, where models are automatically discoverable.

Since then, I’ve expanded support to major online AI providers while maintaining that same simplicity through a modular architecture. The system now handles multiple providers without adding complexity to the user experience.

Another key feature is the customizable menu system, which integrates with role-based switching. You can create specialized AI menus for different contexts, like a coding-focused setup or a writing-optimized configuration and switch between them instantly. Everything is fully configurable to match your workflow.

Links

Here are some links:

https://github.com/captainflasmr/ollama-buddy https://melpa.org/#/ollama-buddy

I will outline the major features below, but I do have a manual available!

https://github.com/captainflasmr/ollama-buddy/blob/main/docs/ollama-buddy.org

Key Features

Multiple AI Providers

Local Models: Full support for Ollama with automatic model management
Cloud Services: Integrated support for OpenAI (ChatGPT), Anthropic Claude, Google Gemini, and Grok
Seamless Switching: Change between local and cloud models with a single command
Unified Interface: Same commands work across all providers

Preset Roles: Switch between different AI personalities (developer, writer, analyst, etc.)
Custom Roles: Create specialized workflows with specific models and parameters
Menu Customization: Each role can have its own set of commands and shortcuts

Chat Interface

Org-mode Integration: Conversations rendered in structured org-mode format
Real-time Streaming: Watch responses appear token by token
Context Management: Visual context window monitoring with usage warnings
History Tracking: Full conversation history with model-specific storage

File Handling

File Attachments: Attach documents directly to conversations for context-aware analysis
Vision Support: Upload and analyse images with vision-capable models
Dired Integration: Bulk attach files directly from Emacs file manager

Prompt Management

System Prompts: Create and manage reusable system prompts for different use cases
Fabric Integration: Auto-sync with Fabric patterns (200+ professional prompts)
Awesome ChatGPT Prompts: Built-in access to the popular prompt collection
User Prompts: Create and organize your own custom prompt library (which of course is org based)

Session Management

Save & Restore: Full session persistence including history, attachments, and settings
Session Browser: Visual interface to manage multiple conversation sessions
Auto-naming: Intelligent session naming based on conversation content

Flexible Interface Options

Two Interface Levels: Basic mode for beginners, advanced for power users
Transient Menus: Magit-style discoverable command interface
Custom Menus: Traditional text-based menu system
Keyboard Shortcuts: Comprehensive keybinding system for efficiency, I’m not sure there are any keys left!!

What’s Next?

Version 1.0 represents a stable, foundation, Ollama Buddy has been out there now for a few months with only a single github issue but development continues with:

RAG integration using perhaps the new vecdb package, as mentioned above
Additional AI provider integrations (Perplexity maybe?, any suggestions?)
Auto-completion (not sure how doable this is with ollama, but I do have a prototype)

Building an Emacs Package from Scratch: Cursor Heatmap Tutorial Part 2

James Dyer — Tue, 22 Jul 2025 13:26:00 +0100

In our ongoing quest to construct a new fully functional Emacs package, in Part 1, we built the foundation and have a very basic package for our cursor heatmap package. Now we’re ready to tackle the core challenge, actually tracking where the cursor is and detecting when it moves!

So, where is the cursor?, this seems simple, but with Emacs and of course generally software engineering there are several different approaches and concepts to understand and think about before we move on to some implementation.

Point: The character position in the buffer (like character 1,847)
Line and column: Traditional text coordinates (line 42, column 15)
Window coordinates: Position relative to the current window
Frame coordinates: Position relative to the entire Emacs frame
Pixel coordinates: Exact pixel position on screen

For our heatmap, we want to visualize cursor movement patterns across the entire Emacs interface, so we’ll focus on frame-relative positioning, both pixel-based (for GUI Emacs) and character-based (for terminal Emacs).

Exploring Emacs Coordinate Systems

Let’s start by understanding what information Emacs can give us about cursor position. Add this exploration function to your package:

(defun cursor-heatmap-debug-position ()
 "Show detailed information about current cursor position."
 (interactive)
 (let* ((point-pos (point))
 (line-col (cons (line-number-at-pos) (current-column)))
 (window-edges (window-edges))
 (pixel-pos (when (display-graphic-p)
 (window-absolute-pixel-position))))
 (message "Debug - Point: %d | Line/Col: %s | Window edges: %s | Pixels: %s"
 point-pos line-col window-edges pixel-pos)))

Try this function in different buffers and notice how the values change. You’ll see that:

Point changes based on buffer content and cursor position within text
Line/column reflects traditional text editing coordinates
Window edges show the window boundaries in character units
Pixel position (GUI only) gives exact screen coordinates

Building Our Position Detection System

Now let’s create our core position detection function. We’ll handle both GUI and terminal modes:

(defun cursor-heatmap--get-cursor-position ()
 "Get cursor position as frame-relative coordinates.
Returns (x . y) cons cell or nil if position should be excluded."
 (when (and (not (minibufferp)) ; Skip minibuffer
 (get-buffer-window)) ; Only track visible buffers
 (condition-case err
 (if (display-graphic-p)
 (cursor-heatmap--get-pixel-position)
 (cursor-heatmap--get-character-position))
 (error
 ;; If anything goes wrong, return nil silently
 nil))))

Notice several important design decisions here:

Error Handling: We wrap everything in condition-case because cursor position detection can fail in various edge cases (buffer switching, window operations, etc.).

Exclusion Logic: We skip the minibuffer because it’s typically used for brief interactions, not sustained editing work.

Display Mode Detection: We use different strategies for GUI vs. terminal Emacs.

Implementing Pixel-Based Position Detection

For GUI Emacs, we can get precise pixel coordinates:

(defun cursor-heatmap--get-pixel-position ()
 "Get cursor position using pixel coordinates in GUI mode."
 (let* ((pixel-pos (window-absolute-pixel-position))
 (frame (selected-frame))
 (frame-pixel-width (frame-pixel-width frame))
 (frame-pixel-height (frame-pixel-height frame)))

 (when (and pixel-pos
 (> frame-pixel-width 0)
 (> frame-pixel-height 0))
 (let* ((frame-x-pixel (car pixel-pos))
 (frame-y-pixel (cdr pixel-pos))
 ;; Normalize to 0.0-1.0 range
 (normalized-x (/ (float frame-x-pixel) frame-pixel-width))
 (normalized-y (/ (float frame-y-pixel) frame-pixel-height)))

 ;; Return as percentages for easier grid mapping later
 (cons normalized-x normalized-y)))))

This function:

Gets the absolute pixel position of the cursor
Normalizes it to a 0.0-1.0 range relative to the frame size
Returns coordinates that we can easily map to any grid size

Implementing Character-Based Position Detection

Terminal Emacs doesn’t have pixel coordinates, so we use character positions:

(defun cursor-heatmap--get-character-position ()
 "Get cursor position using character coordinates in terminal mode."
 (let* ((window (selected-window))
 (window-edges (window-edges window))
 (window-left (nth 0 window-edges))
 (window-top (nth 1 window-edges))
 (point-pos (window-point window))
 (total-frame-width (frame-width))
 (total-frame-height (frame-height)))

 (when (and (> total-frame-width 0)
 (> total-frame-height 0))
 (save-excursion
 (goto-char point-pos)
 (let* ((current-column (current-column))
 (window-line (count-lines (window-start window) point-pos))
 ;; Calculate frame-relative position
 (frame-column (+ window-left current-column))
 (frame-row (+ window-top window-line))
 ;; Normalize to 0.0-1.0 range
 (normalized-x (/ (float frame-column) total-frame-width))
 (normalized-y (/ (float frame-row) total-frame-height)))

 (cons normalized-x normalized-y))))))

This is more complex because we need to:

Get the current column position (handling tabs correctly)
Calculate which line we’re on relative to the window
Convert window-relative coordinates to frame-relative coordinates
Normalize to the same 0.0-1.0 range as pixel coordinates

Adding Movement Detection

Having a position is only half the battle, we need to detect when the cursor actually moves. Let’s add state tracking:

(defvar cursor-heatmap--last-position nil
 "Last recorded cursor position for movement detection.")

(defvar cursor-heatmap--movement-count 0
 "Total number of cursor movements detected.")

(defun cursor-heatmap--detect-movement ()
 "Check if cursor has moved and record the movement."
 (let ((current-pos (cursor-heatmap--get-cursor-position)))
 (when current-pos
 (when (and cursor-heatmap--last-position
 (not (equal current-pos cursor-heatmap--last-position)))
 ;; This is a real movement!
 (cl-incf cursor-heatmap--movement-count)
 (message "Movement detected! Total movements: %d"
 cursor-heatmap--movement-count))

 ;; Update last position for next comparison
 (setq cursor-heatmap--last-position current-pos))))

Setting Up the Hook System

Emacs provides several hooks we can use to detect cursor movement. The most reliable is post-command-hook, which runs after every command:

(defun cursor-heatmap--setup-tracking ()
 "Set up hooks to track cursor movement."
 (add-hook 'post-command-hook #'cursor-heatmap--detect-movement))

(defun cursor-heatmap--stop-tracking ()
 "Remove movement tracking hooks."
 (remove-hook 'post-command-hook #'cursor-heatmap--detect-movement))

Creating Our First Interactive Commands

Let’s add commands users can run to test our tracking:

;;;###autoload
(defun cursor-heatmap-start-tracking ()
 "Start tracking cursor movements."
 (interactive)
 (cursor-heatmap--setup-tracking)
 (setq cursor-heatmap--last-position (cursor-heatmap--get-cursor-position)
 cursor-heatmap--movement-count 0)
 (message "Cursor movement tracking started"))

;;;###autoload
(defun cursor-heatmap-stop-tracking ()
 "Stop tracking cursor movements."
 (interactive)
 (cursor-heatmap--stop-tracking)
 (message "Cursor movement tracking stopped. Total movements: %d"
 cursor-heatmap--movement-count))

;;;###autoload
(defun cursor-heatmap-show-stats ()
 "Show current tracking statistics."
 (interactive)
 (let ((current-pos (cursor-heatmap--get-cursor-position)))
 (message "Position: %s | Movements: %d | Tracking: %s"
 (if current-pos
 (format "%.3f, %.3f" (car current-pos) (cdr current-pos))
 "unknown")
 cursor-heatmap--movement-count
 (if (memq #'cursor-heatmap--detect-movement post-command-hook)
 "ON" "OFF"))))

The ;;;###autoload comments are special, they tell Emacs to make these functions available even before the package is fully loaded.

Handling Edge Cases

Real-world usage reveals edge cases we need to handle:

(defcustom cursor-heatmap-exclude-minibuffer t
 "Whether to exclude minibuffer from tracking."
 :type 'boolean
 :group 'cursor-heatmap)

(defcustom cursor-heatmap-exclude-special-buffers t
 "Whether to exclude special buffers (starting with space or asterisk)."
 :type 'boolean
 :group 'cursor-heatmap)

(defun cursor-heatmap--should-track-buffer-p ()
 "Return non-nil if current buffer should be tracked."
 (and (not (and cursor-heatmap-exclude-minibuffer
 (minibufferp)))
 (not (and cursor-heatmap-exclude-special-buffers
 (string-match "^[ *]" (buffer-name))))
 (get-buffer-window))) ; Only track visible buffers

Update our position function to use this check:

(defun cursor-heatmap--get-cursor-position ()
 "Get cursor position as frame-relative coordinates.
Returns (x . y) cons cell or nil if position should be excluded."
 (when (cursor-heatmap--should-track-buffer-p)
 (condition-case err
 (if (display-graphic-p)
 (cursor-heatmap--get-pixel-position)
 (cursor-heatmap--get-character-position))
 (error nil))))

Testing Our Movement Detection

Let’s create a comprehensive test function:

(defun cursor-heatmap-test-detection ()
 "Interactive test of cursor position detection."
 (interactive)
 (if (memq #'cursor-heatmap--detect-movement post-command-hook)
 (message "Tracking already active. Use cursor-heatmap-stop-tracking to stop.")
 (cursor-heatmap-start-tracking)
 (message "Move your cursor around, then run cursor-heatmap-show-stats")))

Our Complete Progress So Far

Here’s what we’ve built in this post:

;; Add these to your cursor-heatmap.el file after the customization variables

(require 'cl-lib) ; For cl-incf

;; State variables
(defvar cursor-heatmap--last-position nil
 "Last recorded cursor position for movement detection.")

(defvar cursor-heatmap--movement-count 0
 "Total number of cursor movements detected.")

;; New customization options
(defcustom cursor-heatmap-exclude-minibuffer t
 "Whether to exclude minibuffer from tracking."
 :type 'boolean
 :group 'cursor-heatmap)

(defcustom cursor-heatmap-exclude-special-buffers t
 "Whether to exclude special buffers (starting with space or asterisk)."
 :type 'boolean
 :group 'cursor-heatmap)

;; Core detection functions
(defun cursor-heatmap--should-track-buffer-p ()
 "Return non-nil if current buffer should be tracked."
 (and (not (and cursor-heatmap-exclude-minibuffer
 (minibufferp)))
 (not (and cursor-heatmap-exclude-special-buffers
 (string-match "^[ *]" (buffer-name))))
 (get-buffer-window)))

(defun cursor-heatmap--get-pixel-position ()
 "Get cursor position using pixel coordinates in GUI mode."
 (let* ((pixel-pos (window-absolute-pixel-position))
 (frame (selected-frame))
 (frame-pixel-width (frame-pixel-width frame))
 (frame-pixel-height (frame-pixel-height frame)))

 (when (and pixel-pos
 (> frame-pixel-width 0)
 (> frame-pixel-height 0))
 (let* ((frame-x-pixel (car pixel-pos))
 (frame-y-pixel (cdr pixel-pos))
 (normalized-x (/ (float frame-x-pixel) frame-pixel-width))
 (normalized-y (/ (float frame-y-pixel) frame-pixel-height)))
 (cons normalized-x normalized-y)))))

(defun cursor-heatmap--get-character-position ()
 "Get cursor position using character coordinates in terminal mode."
 (let* ((window (selected-window))
 (window-edges (window-edges window))
 (window-left (nth 0 window-edges))
 (window-top (nth 1 window-edges))
 (point-pos (window-point window))
 (total-frame-width (frame-width))
 (total-frame-height (frame-height)))

 (when (and (> total-frame-width 0)
 (> total-frame-height 0))
 (save-excursion
 (goto-char point-pos)
 (let* ((current-column (current-column))
 (window-line (count-lines (window-start window) point-pos))
 (frame-column (+ window-left current-column))
 (frame-row (+ window-top window-line))
 (normalized-x (/ (float frame-column) total-frame-width))
 (normalized-y (/ (float frame-row) total-frame-height)))
 (cons normalized-x normalized-y))))))

(defun cursor-heatmap--get-cursor-position ()
 "Get cursor position as frame-relative coordinates.
Returns (x . y) cons cell or nil if position should be excluded."
 (when (cursor-heatmap--should-track-buffer-p)
 (condition-case err
 (if (display-graphic-p)
 (cursor-heatmap--get-pixel-position)
 (cursor-heatmap--get-character-position))
 (error nil))))

(defun cursor-heatmap--detect-movement ()
 "Check if cursor has moved and record the movement."
 (let ((current-pos (cursor-heatmap--get-cursor-position)))
 (when current-pos
 (when (and cursor-heatmap--last-position
 (not (equal current-pos cursor-heatmap--last-position)))
 (cl-incf cursor-heatmap--movement-count))
 (setq cursor-heatmap--last-position current-pos))))

(defun cursor-heatmap--setup-tracking ()
 "Set up hooks to track cursor movement."
 (add-hook 'post-command-hook #'cursor-heatmap--detect-movement))

(defun cursor-heatmap--stop-tracking ()
 "Remove movement tracking hooks."
 (remove-hook 'post-command-hook #'cursor-heatmap--detect-movement))

;; Interactive commands
;;;###autoload
(defun cursor-heatmap-start-tracking ()
 "Start tracking cursor movements."
 (interactive)
 (cursor-heatmap--setup-tracking)
 (setq cursor-heatmap--last-position (cursor-heatmap--get-cursor-position)
 cursor-heatmap--movement-count 0)
 (message "Cursor movement tracking started"))

;;;###autoload
(defun cursor-heatmap-stop-tracking ()
 "Stop tracking cursor movements."
 (interactive)
 (cursor-heatmap--stop-tracking)
 (message "Cursor movement tracking stopped. Total movements: %d"
 cursor-heatmap--movement-count))

;;;###autoload
(defun cursor-heatmap-show-stats ()
 "Show current tracking statistics."
 (interactive)
 (let ((current-pos (cursor-heatmap--get-cursor-position)))
 (message "Position: %s | Movements: %d | Tracking: %s"
 (if current-pos
 (format "%.3f, %.3f" (car current-pos) (cdr current-pos))
 "unknown")
 cursor-heatmap--movement-count
 (if (memq #'cursor-heatmap--detect-movement post-command-hook)
 "ON" "OFF"))))

;;;###autoload
(defun cursor-heatmap-test-detection ()
 "Interactive test of cursor position detection."
 (interactive)
 (if (memq #'cursor-heatmap--detect-movement post-command-hook)
 (message "Tracking already active. Use cursor-heatmap-stop-tracking to stop.")
 (cursor-heatmap-start-tracking)
 (message "Move your cursor around, then run cursor-heatmap-show-stats")))

;; Debug helper
(defun cursor-heatmap-debug-position ()
 "Show detailed information about current cursor position."
 (interactive)
 (let* ((point-pos (point))
 (line-col (cons (line-number-at-pos) (current-column)))
 (window-edges (window-edges))
 (pixel-pos (when (display-graphic-p)
 (window-absolute-pixel-position)))
 (our-pos (cursor-heatmap--get-cursor-position)))
 (message "Point: %d | Line/Col: %s | Edges: %s | Pixels: %s | Our pos: %s"
 point-pos line-col window-edges pixel-pos our-pos)))

What We’ve Accomplished

In this post, we’ve built the core tracking system:

✅ Position detection: Works in both GUI and terminal modes ✅ Movement detection: Only counts actual cursor movements ✅ Error handling: Gracefully handles edge cases ✅ Hook system: Reliable tracking using Emacs’ event system ✅ Interactive testing: Commands to start, stop, and debug tracking ✅ Customization: User control over what gets tracked

Testing Your Implementation

Try these exercises to verify everything works:

Load and test: Reload your package and run cursor-heatmap-test-detection
Move around: Navigate between buffers, windows, and frames
Check stats: Run cursor-heatmap-show-stats to see movement counts
Debug position: Use cursor-heatmap-debug-position to see raw coordinate data
Test exclusions: Try the minibuffer and special buffers

Common Issues and Solutions

“Position always nil”: Check that you’re in a visible buffer and not a special buffer.

“No movements detected”: Make sure tracking is active and you’re making actual movements, not just staying in one place.

“Coordinates seem wrong”: This is normal, we’re getting normalized coordinates (0.0-1.0) that we’ll map to grids later.

Looking Ahead

In Part 3, we’ll transform these normalized coordinates into a grid system and start building our data structures for the heatmap. We’ll cover:

Mapping coordinates to grid cells
Creating efficient storage for movement data
Handling different grid sizes
Building the foundation for visualization

The tracking system we built today is the engine that will power our entire heatmap, everything else builds on this foundation.

Your Turn: Hands-On Exercise

Extend the tracking system:

Add buffer tracking: Modify the system to track which buffer movements occur in
Add time tracking: Record timestamps with movements
Create a movement log: Store the last 10 movements for debugging
Experiment with hooks: Try different hooks beyond post-command-hook

Next Time

In Part 3, we’ll build the grid mapping system that transforms our position data into the structure needed for heatmap visualization.

Building a New Package From Scratch - Cursor Heatmap Pt1

James Dyer — Sun, 20 Jul 2025 13:17:00 +0100

Lets Create a New Package!

Given that I now have greater experience in Emacs package creation, I thought I would create a short series of blog posts over the next few weeks in taking an initial idea I have for a new Emacs package and working it up into a full, working version!

The idea here is to hopefully be useful to someone who has an idea for doing something new in Emacs and would like to start working it up into a package. There are resources out there, but I thought I would give a go at creating my own.

As usual with writing a blog and having to explain a concept to someone in an understandable format, I suspect that I’m also actually likely to learn something from this activity.

Right, so what is my idea?

Have you ever wondered where your cursor/point spends most of its time when you are fiddling around with Emacs?, do you generally split two windows side-by-side and which window do you typically work in?, do you use olivetti or a similar mode to centralise the text, do you use a four window split on a large monitor and where do you spend most of your time?

So how about an Emacs package that monitors your cursor/point position and can provide a graphical report showing by some kind of graphical heat map the often used Emacs window locations

Lets quickly break this concept down into a very high level design (so high it is in fact just a speck!), should we go the full software engineering approach and define requirements?, then start deriving a design, (maybe not!), so lets see what functional aspects we can start with:

Tracks cursor movements throughout your Emacs editing session
Creates a visual heat map showing movement patterns
Provides analytics about your editing behaviour
Persists data across sessions so we can have recall and overall data across many days

Building Our Foundation

Lets crack on and get something down on paper and begin with the absolute minimum structure and expand from there.

Step 1: Create the Basic File Structure

Create a new file called cursor-heatmap.el with the following contents:

;;; cursor-heatmap.el --- Monitor and visualize cursor movement patterns -*- lexical-binding: t; -*-

;; Copyright (C) 2025

;; Author: Your Name <your.email@example.com>
;; Version: 0.1.0
;; Package-Requires: ((emacs "26.1"))
;; Keywords: tools, analytics, visualization
;; URL: https://github.com/yourusername/cursor-heatmap

;;; Commentary:

;; This package will monitor cursor movements throughout an Emacs session and
;; generate heatmap reports showing where you move your cursor most frequently.
;;
;; Basic usage (to be implemented):
;; M-x cursor-heatmap-mode - start tracking
;; M-x cursor-heatmap-show-report - view results

;;; Code:

;; Package implementation will go here

(provide 'cursor-heatmap)

;;; cursor-heatmap.el ends here

Step 2: Understanding Key Components

Why lexical-binding: t?

This enables modern variable scoping in Emacs Lisp. Without it, all variables have dynamic scope, which can lead to surprising behaviour and bugs. Always use lexical binding for new packages.

The provide statement:

(provide 'cursor-heatmap)

This tells Emacs that loading this file provides the cursor-heatmap feature. Other packages can then use (require 'cursor-heatmap) to load your package.

There are other more advanced ways of loading packages but we shall stick with the basic built-in Emacs package.el for now.

Version numbering:

We start with 0.1.0 following a simple versioning mechanism. As we add features, we’ll increment appropriately.

Step 3: Setting Up Customization Groups

One of Emacs’ greatest strengths is customizability. Let’s set up a customization group for our package:

;;; Code:

(defgroup cursor-heatmap nil
 "Cursor movement heatmap monitoring and visualization."
 :group 'tools
 :prefix "cursor-heatmap-")

This creates a customization group that will appear under the “Tools” category in Emacs’ customization interface. Users can access it via M-x customize-group cursor-heatmap

Step 4: Adding Our First Variables

Let’s add some basic configuration variables:

(defcustom cursor-heatmap-grid-width 100
 "Width of the heatmap grid (number of columns)."
 :type 'integer
 :group 'cursor-heatmap)

(defcustom cursor-heatmap-grid-height 50
 "Height of the heatmap grid (number of rows)."
 :type 'integer
 :group 'cursor-heatmap)

The defcustom macro creates variables that users can customize through the Emacs’ interface. The :type specification helps Emacs validate user input and provide appropriate UI widgets.

Package Naming Conventions

Notice how all our variables start with cursor-heatmap- This is a crucial convention in Emacs package development:

Prevents namespace collisions: With thousands of packages, prefixing prevents conflicts
Makes code searchable: Users can easily find all functions related to your package
Shows ownership: Clear indication of what belongs to your package

Common patterns:

Variables: cursor-heatmap-variable-name
Functions: cursor-heatmap-function-name
Internal functions: cursor-heatmap--internal-function (note the double dash)

Testing Our Foundation

Let’s make sure our basic structure works. Add this simple function to test:

(defun cursor-heatmap-hello ()
 "Test function to verify package structure."
 (interactive)
 (message "Cursor heatmap package loaded successfully! Grid size: %dx%d"
 cursor-heatmap-grid-width cursor-heatmap-grid-height))

Now you can:

Load the file: M-x load-file and select cursor-heatmap.el
Test it: M-x cursor-heatmap-hello
Check customization: M-x customize-group cursor-heatmap

Our Complete Foundation

Here’s our complete foundation file, I think I shall show this at the end of each post so progress can be monitored.

;;; cursor-heatmap.el --- Monitor and visualize cursor movement patterns -*- lexical-binding: t; -*-

;; Copyright (C) 2025

;; Author: Your Name <your.email@example.com>
;; Version: 0.1.0
;; Package-Requires: ((emacs "26.1"))
;; Keywords: tools, analytics, visualization
;; URL: https://github.com/yourusername/cursor-heatmap

;;; Commentary:

;; This package will monitor cursor movements throughout an Emacs session and
;; generate heatmap reports showing where you move your cursor most frequently.
;;
;; Basic usage (to be implemented):
;; M-x cursor-heatmap-mode - start tracking
;; M-x cursor-heatmap-show-report - view results

;;; Code:

(defgroup cursor-heatmap nil
 "Cursor movement heatmap monitoring and visualization."
 :group 'tools
 :prefix "cursor-heatmap-")

(defcustom cursor-heatmap-grid-width 100
 "Width of the heatmap grid (number of columns)."
 :type 'integer
 :group 'cursor-heatmap)

(defcustom cursor-heatmap-grid-height 50
 "Height of the heatmap grid (number of rows)."
 :type 'integer
 :group 'cursor-heatmap)

(defun cursor-heatmap-hello ()
 "Test function to verify package structure."
 (interactive)
 (message "Cursor heatmap package loaded successfully! Grid size: %dx%d"
 cursor-heatmap-grid-width cursor-heatmap-grid-height))

(provide 'cursor-heatmap)

What We’ve Accomplished

In this first post, we’ve established the foundation of our Emacs package:

Package structure: Proper header, metadata, and organization
Customization system: User-configurable options with validation
Naming conventions: Consistent, collision-free naming
Basic functionality: A working, loadable package
Testing framework: Simple way to verify our progress

Next Time

In the next post, we’ll dive into the core functionality: tracking cursor position.

We’ll explore:

How Emacs represents cursor positions
Different coordinate systems (pixels vs. characters)
Setting up our first movement detection
Handling edge cases and error conditions

Red pandas also love Emacs!

James Dyer — Thu, 10 Jul 2025 12:55:00 +0100

Not much of a post this week (and in fact this is pretty low effort!), but here I present some fun with image generative AI!

That is all 😀

New Package! - Simply Annotate: A Lightweight Annotation System

James Dyer — Fri, 04 Jul 2025 22:43:00 +0100

Yes thats right, yet another annotation system!, in this case it is a lightweight annotation system for Emacs that allows you to add persistent notes to any text file without modifying the original content.

https://melpa.org/#/simply-annotate https://github.com/captainflasmr/simply-annotate

Still not convinced it is any different to any other note taking package in Emacs given that previous generic sparse description? Well I shall do my best to explain my own note taking ideas. Of course this is also just a pet project to continue to learn elisp, so there is that too :)

I developed this package to fill my own perceived gap in the existing Emacs note-taking ecosystem. Although annotate.el comes close to what I needed, I wanted a simplified version and something with a few workflow adjustments that better suit my note taking preferences. The result is a lightweight alternative that handles annotations the way I have always wanted them to work.

The main functional aspects that I felt were important to me that generally differ from other existing Emacs annotation packages are:

Header-line status display with keybinding reminders
Simple intuitive workflow (hopefully)
Multiple display styles (highlight, fringe indicators, or both)
Annotation editing via a dedicated buffer
Lightweight (if possible <1000 lines - [UPDATE], no its not possible, lets try <2000 lines!)
Multi-purpose key to show/edit/toggle annotations
Dedicated annotation buffer that can pop in and out
Quickly step through annotations with M-n and M-p
Buffer summary of annotations in grep-mode format
Quickly browse through all annotated files using completing-read
Smart action command that adapts based on context
Threading conversations for each annotation

See https://github.com/captainflasmr/simply-annotate/blob/main/docs/simply-annotate.org for the manual!

Quick Demo Video

Open this file and open the simply-annotate.el file

highlight some regions and put in some annotation comments
step through annotation comments
show summary
delete some annotations

Go to the directory level and now browse the 2 files

Whats New

<2025-07-03 Thu> 0.6.0

A little refactoring and tidying up.

<2025-06-29 Sun> 0.5.1

Raw sexp editing: Edit annotation data structures directly as Elisp for complete control
Advanced editing capabilities: Full access to thread metadata, status, priority, and comments

Updated Key Bindings:

M-s e: Edit annotation as raw Elisp sexp

<2025-06-20 Fri> 0.5.0

Threading system: Add replies to annotations for conversations
Status management: Track progress (open, in-progress, resolved, closed)
Priority levels: Set importance (low, normal, high, critical)
Multi-author support: Configure team members for collaboration
Tag system: Organize with hashtags (#review, #bug, #question)
Org-mode export: Convert threads to structured TODO items
Enhanced display: Thread info in headers and lists
Author management: Flexible prompting modes and author changes

New Key Bindings:

M-s r: Add reply to annotation
M-s s: Set status
M-s p: Set priority
M-s t: Add tag
M-s a: Change author
M-s o: Export to org-mode

<2025-06-20 Fri> 0.0.1

Basic annotation functionality
Persistent storage
Navigation commands
Org-mode export
Customizable highlighting

Installation

MELPA (Recommended)

(use-package simply-annotate
 :bind ("C-c A" . simply-annotate-mode))

Manual Installation

Download simply-annotate.el
Place it in your Emacs load-path
Add to your configuration:

(require 'simply-annotate)
(global-set-key (kbd "C-c A") simply-annotate-mode)

Quick Start

Open any file
Enable annotation mode: M-x simply-annotate-mode
Select/mark text and press M-s j to create your first annotation
Create some more annotations
Navigate with M-n (next) and M-p (previous)
Add replies: Press M-s r on any annotation to reply
Set status: Press M-s s to track progress (open/resolved/etc.)
Advanced editing: Press M-s e to edit annotation data structure directly

Usage

Enabling Annotation Mode

M-x simply-annotate-mode

Or bind to a convenient key:

(global-set-key (kbd "C-c A") 'simply-annotate-mode)

Creating Annotations

Simple

The M-s j command (simply-annotate-smart-action) is context-aware:

With region selected: Creates new annotation or edits existing one
On annotated text: Toggles annotation buffer visibility
With prefix (C-u M-s j): Forces edit mode on existing annotation
Elsewhere: Creates annotation for current line
Enter your annotation text in the dedicated buffer
Save with C-c C-c

Advanced Editing

Raw Sexp Editing

For complete control over annotation data structures:

Place cursor on any annotation
Press M-s e to open the raw sexp editor
Edit the Elisp data structure directly:
- Modify thread metadata (status, priority, tags)
- Edit comment text and timestamps
- Add/remove/reorder comments
- Change author information
Save with C-c C-c or cancel with C-c C-k

Example sexp structure:

((id . "thread-123456")
 (created . "2025-06-29T10:30:00")
 (status . "open")
 (priority . "high")
 (tags . ("bug" "critical"))
 (comments . (((author . "John Doe")
 (timestamp . "2025-06-29T10:30:00")
 (text . "Found a critical bug here")
 (type . "comment"))
 ((author . "Jane Smith")
 (timestamp . "2025-06-29T11:15:00")
 (text . "I can reproduce this issue")
 (type . "reply")))))

Threading & Collaboration

Adding Replies

Place cursor on any annotation
Press M-s r to add a reply
Enter your response
The annotation becomes a threaded conversation

Status Management

Press M-s s to set status: open, in-progress, resolved, closed
Press M-s p to set priority: low, normal, high, critical
Press M-s t to add tags like #review, #bug, #question

Author Management

Configure for single-user or team workflows:

;; Single user (default behavior)
(setq simply-annotate-prompt-for-author nil)

;; Team collaboration
(setq simply-annotate-author-list '("John Doe" "Jane Smith" "Bob Wilson"))
(setq simply-annotate-prompt-for-author 'threads-only) ; Prompt only for replies
(setq simply-annotate-remember-author-per-file t) ; Remember per file

Available prompting modes:

nil: Never prompt (single-user mode)
'first-only: Prompt once per session
'always: Prompt for every annotation
'threads-only: Prompt only for thread replies (great for reviews)

Author Commands

M-s a: Change author of existing annotation/comment

Display Styles

Simply Annotate supports three display styles:

Highlight: Traditional background highlighting (default)
Fringe: Shows indicators in the left fringe
Both: Combines highlighting with fringe indicators

Change styles with M-s ] or customize simply-annotate-display-style.

Viewing Annotations

When simply-annotate-mode is active:

Annotated text is displayed according to your chosen style
The header line shows annotation count, status info, and available commands
* Thread info*: Header shows [OPEN/HIGH:3] for status, priority, and comment count
Moving to annotated text shows annotation details in the header
Press M-s j on annotated text to view/edit in detail

Key Binding	Action
`M-n`	Jump to next annotation
`M-p`	Jump to previous annotation
`M-s j`	Smart action (context-aware)

Managing Annotations

Creating

Select/mark some text
Press M-s j to open the annotation buffer
Make your changes
Save with C-c C-c

Editing

Standard Editing:

Place cursor on annotated text
Press C-u M-s j to open the annotation buffer
Make your changes
Save with C-c C-c

Advanced Sexp Editing:

Place cursor on annotated text
Press M-s e to open the raw sexp editor
Edit the complete data structure
Save with C-c C-c or cancel with C-c C-k

Deleting

Place cursor on annotated text
Press M-s - to remove the annotation

Listing All Annotations

Press M-s l to open a grep-mode buffer showing all annotations in the current file
Enhanced display: Shows thread status, priority, comment counts, and author info
Click on line numbers, press Enter or n/p keys to jump directly to annotations
Perfect for getting an overview of all your notes and their status

Cross-file Overview

Press M-s 0 to browse annotations across all files
Select a file from the completion list
Statistics: Shows annotation counts and status summaries per file
View all annotations for that file in grep-mode format
Source file is presented along with grep-mode list of annotations

Org-mode Integration

Export your annotation threads to org-mode files for further processing:

Press M-s o to export current buffer annotations to an org file
Each thread becomes a TODO item with proper metadata
Replies become sub-entries
Status, priority, tags, and timestamps are preserved

Tips and Tricks

Workflow Suggestions

Enable the mode globally if you wish for all files!

(use-package simply-annotate
 :hook
 (find-file-hook . simply-annotate-mode)
 :bind
 ("C-c A" . simply-annotate-mode)
 ("C-c 0" . simply-annotate-show-all))

Smart Action Usage Patterns

Quick annotation: No selection, M-s j to annotate current line
Edit existing: C-u M-s j on annotated text to force edit mode
Toggle view: M-s j on annotated text to show/hide annotation buffer
Region annotation: Select text, M-s j to create detailed annotation

Advanced Editing Tips

Bulk operations: Use M-s e to edit multiple comments at once in sexp mode
Data migration: Copy annotation structures between files using sexp editing
Precision control: Manually adjust timestamps, IDs, or metadata via sexp editing
Complex threading: Create sophisticated reply structures that aren’t possible through the UI

Display Style Tips

Use fringe mode for code files to minimize visual distraction
Use highlight mode for documents where you want emphasis
Use both mode for critical files requiring maximum attention
Change styles on-the-fly with M-s ] based on current task

Performance Notes

Annotations are loaded on-demand per buffer
Large numbers of annotations (100+) may slightly impact performance
Fringe mode generally has better performance than highlight mode
Threading: Complex threads (10+ replies) may slow annotation buffer rendering
Sexp editing: Large annotation structures may take a moment to format and parse

Setting up a C# Language Server (csharp-ls) on an Air-Gapped Windows System

James Dyer — Fri, 27 Jun 2025 22:27:00 +0100

For a little while now, I have been developing C# applications at work and on Windows!, possibly the perfect storm for Emacs, but actually, it copes pretty well, especially with eglot and the LSP server OmniSharp.

But recently my work setup has become even more air-gapped, and unfortunately, I reached a point where I couldn’t get eglot and OmniSharp working together. I gave it a really good try, but I think the mishmash and dependency installation madness finally took a toll.

It has something to do with trying to find MSBuild.exe, but due to my potentially wonky installation, I couldn’t figure out how to detect it. If Visual Studio is installed on the system, there are no problems; however, offline installation, even of the Community edition, is not an easy task.

So, the solution? Well, I thought I would try another C# LSP in the form of csharp-ls. Its deliverable form is a NuGet package, which can be extracted, placed in the relevant location, and then you’re pretty much off and running!

So here is how I did it:

Step 1: Download csharp-ls nuget Components

On a machine with internet access (which fortunately I do have access to):

Download csharp-ls

Go to the csharp-ls NuGet page
Click “Download package” to get the .nupkg file
Rename the file from .nupkg to .zip
Extract the contents

Step 2: Install csharp-ls (Airgapped Machine)

Create a directory in your Emacs installation:
```
 mkdir "c:\path\to\emacs\bin\csharp-ls"
```
Copy the extracted csharp-ls contents to this directory. The key file you need is:
```
 tools\net9.0\any\CSharpLanguageServer.dll
```

Step 3: Configure Emacs

Add this configuration to your Emacs init file:

;; Configure csharp-ls as the language server for C#
(setq eglot-server-programs
 '((csharp-mode . ("dotnet" "c:/path/to/emacs/bin/csharp-ls/tools/net9.0/any/CSharpLanguageServer.dll"))))

Step 4: Set Up Your C# Project Structure

Basically defining a source code collection as a project in Emacs. This can be a solution file, a source code control directory or as I generally have set up, an empty .project file

Step 5: Set up paths

This may not be needed, but for my own sanity and just in case, absorb the new directory in to the PATH and exec-path variables.

(when (eq system-type 'windows-nt)
 (let ((xPaths
 `(
 ,(expand-file-name "~/bin/csharp-ls/tools/net9.0/any")
 )))
 (setenv "PATH" (concat
 (mapconcat 'identity xPaths ";")))
 (setq exec-path (append (split-string winPaths ";") xPaths (list "." exec-directory)))))

So it works as I had it with OmniSharp and that really is all I can ask for, lets see how I get on!

Ollama-Buddy 0.13.1: Curl backend support and some optimizations

James Dyer — Sat, 21 Jun 2025 10:05:00 +0100

This is more of a maintenance update. The main headline is the addition of an option to select a curl-based backend for those who may encounter networking issues. By default, ollama-buddy uses built-in low-level networking calls, but if you have network issues, you can now switch to curl!

<2025-06-21 Sat> 0.13.1

Refactored content register processing to be more efficient and added a new Emacs package brainstorming prompt file.

<2025-06-15 Sun> 0.13.0

Added curl communication backend with fallback support

Added ollama-buddy-curl.el as separate backend implementation
Implemented backend dispatcher system in ollama-buddy-core.el
Updated all async functions to use backend dispatcher
Added curl backend validation and testing functions
Maintained full compatibility with existing network process backend

When building Emacs packages that communicate with external services, network connectivity can sometimes be a pain point. While Emacs’s built-in make-network-process works great in most cases, some users have encountered issues on certain systems or network configurations. That’s why now I have added a curl-based communication backend to give you an additional option, who knows, maybe it will solve your ollama communication issues!

The original ollama-buddy implementation relied exclusively on Emacs’s native network process functionality. While this works well for most users, I occasionally heard from users who experienced network process failures/flakiness on certain systems.

Rather than trying to work around these edge cases in the network process code, I took a different approach: I added curl as an alternative communication backend! This gives users a battle-tested, widely-available HTTP client as a fallback option.

Users can enable the curl backend with a simple customization:

(use-package ollama-buddy
 :bind
 ("C-c o" . ollama-buddy-menu)
 ("C-c O" . ollama-buddy-transient-menu-wrapper)
 :config
 ;; Load curl backend first
 (require 'ollama-buddy-curl nil t)

 ;; Then set the backend
 (setq ollama-buddy-communication-backend 'curl))

and then switch backends from the chat buffer C-c e

The curl backend supports everything the network backend does:

Real-time streaming responses
Vision model support with image attachments
File attachments and context
All Ollama API parameters
Multishot model sequences

If curl is selected but not available, the system automatically falls back to the network process with a helpful warning message.

From a user perspective, the backend choice is largely transparent. The main indicators are:

Status line shows [C] for curl or [N] for network
Process list shows ollama-chat-curl vs ollama-chat-stream processes
Curl backend shows “Curl Processing…” in status messages

Everything else - streaming behaviour, response formatting, error handling - works identically regardless of the backend.

<2025-05-31 Sat> 0.12.1

Optimized Unicode escape function to fix blocking with large file attachments

Fixed UI blocking when sending large attached files
Used temp buffer with delete-char/insert instead of repeated concat calls
Reduced processing time from minutes to milliseconds for large payloads

Emacs dired with Ultra-Lightweight Visual Icons

James Dyer — Thu, 12 Jun 2025 22:37:00 +0100

If you spend any time browsing files in Emacs, you’ve probably wished for a bit more visual distinction in dired buffers?. While packages like all-the-icons-dired provide beautiful icon sets, they come with dependencies, font requirements, and potential compatibility issues. What if you could get meaningful visual file type indicators with just a few simple lines of pure Elisp? I have adapted the original idea provided by Emacs-solo and focused more on the earlier Unicode characters that are most likely to always be present in an Emacs environment.

Popular dired icon packages often require:

Installing specific icon fonts
Managing font fallbacks across different systems
Dealing with alignment issues in terminal Emacs
Large dependency chains that slow down startup
Compatibility headaches when sharing configs

I have also noticed that Emacs can just crash if it is dealing with an icon that isn’t installed on the system.

Here’s an implementation that adds visual file type indicators using only standard Unicode characters. Of course the icons-map isn’t exhaustive but might be a sensible minimal starting point.

(defvar dired-icons-map
 '(("el" . "λ") ("rb" . "◆") ("js" . "○") ("ts" . "●") ("json" . "◎") ("md" . "■")
 ("txt" . "□") ("html" . "▲") ("css" . "▼") ("png" . "◉") ("jpg" . "◉")
 ("pdf" . "▣") ("zip" . "▢") ("py" . "∆") ("c" . "◇") ("sql" . "▦")
 ("mp3" . "♪") ("mp4" . "▶") ("exe" . "▪")))

(defun dired-add-icons ()
 (when (derived-mode-p 'dired-mode)
 (let ((inhibit-read-only t))
 (save-excursion
 (goto-char (point-min))
 (while (and (not (eobp)) (< (line-number-at-pos) 200))
 (condition-case nil
 (let ((line (buffer-substring-no-properties (line-beginning-position) (line-end-position))))
 (when (and (> (length line) 10)
 (string-match "\\([rwxd-]\\{10\\}\\)" line)
 (dired-move-to-filename t)
 (not (looking-at "[▶◦λ◆○●◎■□▲▼◉▣▢◇∆▦♪▪] ")))
 (let* ((is-dir (eq (aref line (match-beginning 1)) ?d))
 (filename (and (string-match "\\([^ ]+\\)$" line) (match-string 1 line)))
 (icon (cond (is-dir "▶")
 ((and filename (string-match "\\.\\([^.]+\\)$" filename))
 (or (cdr (assoc (downcase (match-string 1 filename)) dired-icons-map)) "◦"))
 (t "◦"))))
 (insert icon " "))))
 (error nil))
 (forward-line))))))

(add-hook 'dired-after-readin-hook 'dired-add-icons)

The icons use only standard Unicode geometric shapes and mathematical symbols that have been supported in every font since the 1990s. No special fonts required, it works identically in:

Terminal Emacs
GUI Emacs on any platform
Ancient and modern Emacs versions

There are some advantages to be had:

Zero dependencies: Pure Elisp, no external packages
Tiny footprint: 30 lines vs hundreds in full icon packages
Instant startup: No font loading or icon caching
Robust error handling: Gracefully skips problematic files
Performance limits: Processes max 200 files to prevent freezing but of course that can be modified to taste

Once added to your config, it just works. No font updates, no package maintenance, no breaking changes from upstream dependencies.

Here is a typical example:

After:

Before:

Want different icons? Just modify the dired-icons-map:

;; Prefer asterisks for code files?
("js" . "*") ("py" . "*") ("rb" . "*")

;; Like filled shapes for documents?
("md" . "▪") ("txt" . "▪") ("pdf" . "▪")

;; Add your own file types
("log" . "□") ("cfg" . "○") ("bak" . "▫")

Simply copy the code into your init.el and off you go!

Building Your Own Orderless Style Completion in Emacs Lisp

James Dyer — Wed, 04 Jun 2025 09:40:00 +0100

While packages like orderless provide flexible “any word, any order” completion, sometimes you want something lightweight and easy to tweak (well I do anyway). In this post, I’ll show you how to implement a simple orderless-like completion style using only Emacs Lisp, and how to integrate it smoothly into your workflow.

Traditional completion in Emacs often matches prefixes or substrings, but sometimes you want to type a few key parts of a word, in any order, and jump straight to your target. That’s what orderless and similar completion styles allow. But what if you want to write your own, or experiment with the logic?, well I will show you how…

Let’s walk through the logic:

(defun simple-orderless-completion (string table pred point)
 "Enhanced orderless completion with better partial matching."
 (let* ((words (split-string string "[-, ]+"))
 (patterns (mapcar (lambda (word)
 (concat "\\b.*" (regexp-quote word) ".*"))
 words))
 (full-regexp (mapconcat 'identity patterns "")))
 (if (string-empty-p string)
 (all-completions "" table pred)
 (cl-remove-if-not
 (lambda (candidate)
 (let ((case-fold-search completion-ignore-case))
 (and (cl-every (lambda (word)
 (string-match-p
 (concat "\\b.*" (regexp-quote word))
 candidate))
 words)
 t)))
 (all-completions "" table pred)))))

What’s Happening Here?

Word Splitting:

The user’s input (a string) is split into words on spaces, dashes, or commas. This produces a list of “search terms.” This means that, in the minibuffer, the word separator can be any of these characters. I was initially really faffing around and struggling to work out how to insert a space between words in the minibuffer, as it seems to perform some form of completion. However, I eventually figured out that M-SPC actually inserts a space, allowing you to separate words. I use fido-mode, so I’m not sure if this is the same for other minibuffer completion systems.

After initially adding in the comma separator however I found that I actually prefer it, it is easier to access and I don’t think any keywords, functions e.t.c will typically contain a comma?
Pattern Construction:

For each word, a regex pattern is constructed: \\b.*WORD.*. This means: “find a word boundary, followed by any characters, then the word, then anything else.” This is a bit looser than strict word matching, and you can tune it.
Candidate Filtering:

We generate all possible completions with all-completions and then filter them down. For a candidate to match, all the search terms (words) must appear somewhere, in any order.
Case Sensitivity:

Matching respects completion-ignore-case, so your results will be case-insensitive if you want of course.

Registering and Using the Style

To make Emacs aware of your new completion style, add it to completion-styles-alist:

(add-to-list 'completion-styles-alist
 '(simple-orderless simple-orderless-completion
 simple-orderless-completion))

Contextual Use: Minibuffer Only

You might not want this style everywhere (which I suspect is likely). For example, in file completion you might prefer strict prefix matching. So, let’s activate it only in the minibuffer:

(defun setup-minibuffer-completion-styles ()
 "Use orderless completion in minibuffer, regular completion elsewhere."
 ;; For minibuffer: use orderless first, then fallback to flex and basic
 (setq-local completion-styles '(basic simple-orderless flex substring)))

;; Hook into minibuffer setup
(add-hook 'minibuffer-setup-hook #'setup-minibuffer-completion-styles)

Tweaking and Extending

Pattern Tuning:

The regexes can be made stricter or looser (e.g., remove \\b for more “fuzzy” matching).
Word Separators:

You can split on other characters if your workflow uses different delimiters.
Order of Styles:

Adjust the order in completion-styles to prefer your custom style over others. I found that if the simple-orderless style was listed first, pressing Tab to bring up the completions buffer doesn’t work, which I like to use sometimes, so that is why basic is first.

Conclusion

With just a handful of lines, you can build your own orderless-like completion style, giving you full control and transparency. This is a great starting point for experimenting with more advanced completion logic, and a good illustration of the power of Emacs’ built-in completion framework!

Bank Buddy - Your Financial Analysis Companion for Emacs!

James Dyer — Wed, 28 May 2025 08:50:00 +0100

I created a new package!, here are the details:

Bank Buddy is an Emacs package that provides financial analysis and reporting capabilities for your bank statements. It processes CSV bank statement data, categorizes transactions using customizable patterns, and generates detailed reports in Org-mode format.

It does not depend on any external account system, and the analysis is handled by elisp. The only external tool that may be required is gnuplot to visualize the generated data.

Here is an example of the type of report that is generated (obviously using test data :))

https://github.com/captainflasmr/bank-buddy/blob/main/tests/bank-statement_report/bank-statement_report.org

See https://github.com/captainflasmr/bank-buddy/blob/main/docs/bank-buddy.org for the manual!

Key Features

Smart Transaction Categorization: Auto-categorizes transactions based on customizable regex patterns
Financial Reports: Generates detailed reports in Org-mode with:
- Transaction summaries and overviews
- Spending category analysis
- Top merchant identification
- Monthly spending patterns with visual representation
- Recurring subscription detection
Interactive Category Management: Edit and refine categorization patterns directly from reports
Data Visualizations: Generates charts and graphs using external gnuplot scripts
No Reliance on External Accounting System - Analysis is all Emacs built-in
Asynchronous Processing: Efficiently handles large bank statements without blocking Emacs

Screenshots

Monthly Spending categories

Monthly Spending categories (stacked)

Quick Start

Export your bank statement as a CSV file
Edit CSV using csv-mode for all lines to the format DATE,DESCRIPTION,AMOUNT
Open CSV file
Run: M-x bank-buddy-generate
Open the generated report

Generate gnuplots

Since version 0.2.0, Bank Buddy generates external gnuplot scripts that are executed via call-process. You need to have gnuplot installed on your system.

To install gnuplot:

Linux: sudo apt install gnuplot (or equivalent for your distribution)
macOS: brew install gnuplot
Windows: Download from http://www.gnuplot.info/

The generated reports will include links to both the gnuplot script files (.gp) and data files (.dat) for each visualization. This allows for:

Easy customization of plots by editing the gnuplot scripts
Regeneration of plots without reprocessing the CSV data
Better control over visualization settings

Usage Guide

Understanding CSV Format

Bank Buddy expects CSV files with at least the following columns:

Transaction date
Transaction description
Debit amount

Different banks format their CSV exports differently. You may need to preprocess your CSV to match this format, I would advise to use the package csv-mode, open up a csv file and C-c C-k you way to removed unwanted columns so all you have left are those described above.

Example CSV

Date,Description,Amount
2024-06-30,PAYPAL TRANSFER,28.50
2024-06-28,JUST-EAT TAKEAWAY,32.99
2024-06-25,ASDA GROCERIES,78.50
2024-06-22,AUDIBLE SUBSCRIPTION,7.99
2024-06-20,THREE MOBILE,25.00
2024-06-18,RIVER-ISLAND CLOTHES,85.99
2024-06-15,SPOTIFY PREMIUM,9.99
2024-06-12,RAILWAY TICKET,42.00
2024-06-10,AMAZON PURCHASE,55.25
2024-06-07,NETFLIX SUBSCRIPTION,13.99
2024-06-05,VIRGIN-MEDIA MONTHLY,65.50
2024-06-03,NOTEMACHINE WITHDRAWAL,100.00
2024-06-01,KATHERINE ALLOWANCE,200.00
2024-05-30,DENTIST APPOINTMENT,60.00
2024-05-28,SKY-BETTING RACES,25.00
2024-05-25,WAITROSE GROCERIES,115.45
2024-05-22,NOWTV SUBSCRIPTION,9.99
2024-05-20,PAYPAL TRANSFER,40.00
2024-05-18,THREE MOBILE,25.00
2024-05-15,UBER RIDE,18.25
2024-05-12,SAINSBURYS GROCERIES,105.75
2024-05-10,AMAZON PURCHASE,32.99
2024-05-07,NETFLIX SUBSCRIPTION,13.99
2024-05-05,VIRGIN-MEDIA MONTHLY,65.50
2024-05-02,KATHERINE ALLOWANCE,200.00
2024-04-30,DELIVEROO FOOD,25.50
2024-04-28,PRIME VIDEO RENTAL,4.99
2024-04-25,PETS AT HOME,45.00
2024-04-23,RAILWAY TICKET,18.50
2024-04-20,YOUTUBE PREMIUM,11.99
2024-04-18,IKEA FURNITURE,245.99
2024-04-15,TESCO GROCERIES,68.95
2024-04-12,STARBUCKS COFFEE,9.85
2024-04-10,AMAZON PURCHASE,78.50
2024-04-07,NETFLIX SUBSCRIPTION,13.99
2024-04-05,CLAUDE SUBSCRIPTION,20.00
2024-04-03,VIRGIN-MEDIA MONTHLY,65.50
2024-04-01,KATHERINE ALLOWANCE,200.00
2024-03-30,PAYPAL TRANSFER,45.00
2024-03-28,BET365 RACES,30.00
2024-03-25,UBER RIDE,15.75
2024-03-22,WITHDRAWAL ATM,50.00
2024-03-20,THREE MOBILE,25.00
2024-03-17,SAINSBURYS GROCERIES,95.25
2024-03-15,SPECSAVERS APPOINTMENT,25.00
2024-03-12,RAILWAY TICKET,22.50
2024-03-10,AMAZON PURCHASE,28.99
2024-03-07,NETFLIX SUBSCRIPTION,13.99
2024-03-05,NATWEST-BANK-REFERENCE RENT,750.00
2024-03-03,NEXT RETAIL-LTD,125.00
2024-03-01,VIRGIN-MEDIA MONTHLY,65.50
2024-02-28,YOUTUBE PREMIUM,11.99
2024-02-25,SKY SUBSCRIPTION,45.99
2024-02-23,ASDA GROCERIES,92.45
2024-02-20,DISNEY+ SUBSCRIPTION,7.99
2024-02-18,PAYPAL TRANSFER,35.99
2024-02-15,TESCO GROCERIES,75.40
2024-02-12,WATERSTONES BOOK,15.99
2024-02-10,AMAZON PURCHASE,65.75
2024-02-07,NETFLIX SUBSCRIPTION,13.99
2024-02-05,ROYAL-MAIL POSTAGE,8.95
2024-02-03,RAILWAY TICKET,35.45
2024-02-01,KATHERINE ALLOWANCE,200.00
2024-01-30,UBER RIDE,12.50
2024-01-28,STARBUCKS COFFEE,4.95
2024-01-25,THREE MOBILE,25.00
2024-01-20,AMAZON PURCHASE,45.30
2024-01-18,SAINSBURYS GROCERIES,88.75
2024-01-15,NETFLIX SUBSCRIPTION,13.99
2024-01-12,PAYPAL TRANSFER,22.45
2024-01-10,VIRGIN-MEDIA MONTHLY,65.50
2024-01-07,SKY-BETTING RACES,20.00
2024-01-05,PAYPAL TRANSFER,55.99

Generating a Report

To generate a financial report M-x bank-buddy-generate-report

You’ll be prompted to select an input CSV file and specify the output Org file.

The package processes the data asynchronously and a buffer will appear reporting on the analysis progress, so Emacs remains responsive even with large CSV files.

When processing is complete, you’ll be asked if you want to open the generated report.

Understanding the Report

A typical Bank Buddy report includes:

Summary Overview

Total transactions analyzed
Date range
Total, average daily, and weekly spending

Top Spending Categories

Ranked list of spending categories
Total amount, percentage, and monthly/yearly averages
Links to generated gnuplot scripts and data files

Monthly Spending Patterns

Month-by-month spending visualization
Category breakdown for each month
Highest and lowest spending months
Links to visualization files (*.gp, *.dat)

Monthly Category Breakdowns

Detailed charts for each month showing spending by category
Consistent color coding across months for easy comparison
Links to individual gnuplot scripts for customization

Top Merchants

Your highest-spending merchants
Total amount, percentage, and monthly/yearly averages
Links to generated visualization files

Recurring Subscriptions

Detected recurring payments
Estimated monthly cost
Frequency analysis (weekly, bi-weekly, monthly, annual)

Transaction Size Distribution

Analysis of transaction sizes (under £10, £10-50, £50-100, over £100)

Unmatched Transactions

List of transactions that didn’t match specific categories
Suggested patterns to add to your customization

Managing Transaction Categories

Bank Buddy comes with predefined category patterns, but you’ll likely want to customize these for your personal transactions. The package includes an interactive mode for managing categories.

When viewing a report, you can:

Navigate to an unmatched transaction (in the “Unmatched Transactions” section)
Press C-c C-a to add it to a category
Choose an existing category or create a new one
Optionally save the updated category definitions to your init file
Regenerate the report to see the changes

To manage existing categories or add new ones manually, customize bank-buddy-core-cat-list-defines.

Category Format

Categories are defined as patterns in the form:

(REGEX-PATTERN CATEGORY-CODE)

Where:

REGEX-PATTERN is a regular expression that matches transaction descriptions
CATEGORY-CODE is a short code representing the category (e.g., “fod” for food)

For example:

("amazon\\|amz" "amz") ; Amazon purchases
("netflix\\|spotify\\|youtube" "str") ; Streaming services

You can customize category codes and their display names by modifying bank-buddy-core-category-names.

Updating and Regenerating Reports

If you add or modify category patterns after generating a report:

With the report open, enable Bank Buddy Category mode if not already active: M-x bank-buddy-cat-mode
Press C-c C-r to regenerate the report with the updated categories

The report will be refreshed with the new categorization rules.

Example Workflow

Generate Initial Report M-x bank-buddy-generate-report
Review Unmatched Transactions Navigate to the “Unmatched Transactions” section of the report.
Categorize Transactions
- Place cursor on an unmatched transaction
- C-c C-a to add it to a category
- Choose an existing category or create a new one
Regenerate Report
- C-c C-r to see your changes
Save Category Definitions When prompted, choose to save your category definitions to your init file.

Customization

Core Settings

;; Exclude large transactions from analysis
(setq bank-buddy-core-exclude-large-txns t)
(setq bank-buddy-core-large-txn-threshold 2000)

;; Number of occurrences to detect subscriptions
(setq bank-buddy-core-subscription-min-occurrences 3)

;; Number of top items to display
(setq bank-buddy-core-top-spending-categories 5)
(setq bank-buddy-core-top-merchants 5)

Customizing Category Patterns

You can customize the category patterns by setting bank-buddy-core-cat-list-defines:

(customize-set-variable 'bank-buddy-core-cat-list-defines
 '(("amazon\\|amz" "amz")
 ("netflix\\|spotify" "str")
 ("uber\\|lyft" "txi")
 ("sainsburys\\|tesco\\|asda" "fod")
 ;; Add your own patterns here
 (".*" "o"))) ; Catch-all pattern should be last

Customizing Category Names

Category codes are mapped to human-readable names via bank-buddy-core-category-names:

(customize-set-variable 'bank-buddy-core-category-names
 '(("amz" . "Amazon")
 ("str" . "Streaming Services")
 ("txi" . "Taxi & Rideshare")
 ("fod" . "Groceries")
 ;; Add your own mappings here
 ("o" . "Other")))

Customizing Subscription Detection

Define subscription patterns for better detection of recurring payments:

(customize-set-variable 'bank-buddy-core-subscription-patterns
 '(("NETFLIX" . "Netflix")
 ("SPOTIFY" . "Spotify")
 ("AMAZON PRIME" . "Amazon Prime")
 ;; Add your own patterns here
 ))

Advanced Usage

Integration with Other Financial Tools

Bank Buddy reports are generated as Org-mode files, making them compatible with other Org-based tools:

Export to HTML, PDF, or other formats with Org export functions
Use org-capture to add notes to specific transactions or categories

Custom Visualization

Bank Buddy generates visualizations using external gnuplot scripts. You can customize these by:

Editing the generated .gp files in the report directory
Creating your own gnuplot scripts based on the generated .dat files
Running the scripts manually with gnuplot filename.gp

Keyboard Shortcuts

When viewing a report with bank-buddy-cat-mode enabled:

C-c C-a: Add the transaction at point to a category
C-c C-r: Regenerate the report with current category definitions

Caveats and Tips

CSV Format: Bank Buddy expects a CSV with date, description, and amount columns
Performance: For very large CSV files (10K+ rows), the async processing helps but may still take time
Categorization: Start with broad patterns and refine as needed
Visualization: Ensure gnuplot is installed on your system for chart generation
Saving Patterns: Always save your category patterns to persist between sessions

Comparison with Other Financial Packages

Several Emacs packages exist for financial management, but they serve different purposes. Here’s how Bank Buddy compares to other notable financial packages:

Ledger-mode

Ledger-mode is an Emacs interface to the command-line Ledger accounting system.

Key differences:

Ledger is a complete double-entry accounting system; Bank Buddy is focused on bank statement analysis
Ledger requires manual transaction entry or carefully formatted imports; Bank Buddy automates categorization
Ledger offers more comprehensive accounting features (accounts, assets, liabilities); Bank Buddy focuses on spending insights
Bank Buddy provides visual spending breakdowns and charts; Ledger focuses on accurate accounting

When to use Ledger: For complete personal finance tracking, investments, budgeting, and double-entry accounting. When to use Bank Buddy: For quick analysis of bank statements and visualizing spending patterns.

HLedger-mode

HLedger-mode is an Emacs major mode for working with hledger, a plain-text accounting system similar to Ledger.

Key differences:

HLedger, like Ledger, is a full double-entry accounting system; Bank Buddy focuses on bank statement analysis
HLedger requires manual transaction entry or formatted imports; Bank Buddy automates categorization
HLedger offers comprehensive accounting features (multiple currencies, time reporting); Bank Buddy emphasizes spending insights
Bank Buddy provides visual spending breakdowns; HLedger focuses on textual reports and balances

When to use HLedger-mode: For detailed personal finance tracking, multi-currency support, and generating various financial reports. When to use Bank Buddy: For quick analysis of bank statements and visualizing spending patterns without learning a full accounting system.

Elbank

Elbank is a personal finance reporting tool for Emacs that uses Weboob to fetch data from bank websites.

Key differences:

Elbank can automatically fetch transactions from supported banks; Bank Buddy works with CSV exports
Elbank focuses on reporting and visualization; Bank Buddy offers both analysis and reporting
Elbank requires Weboob setup and configuration; Bank Buddy works directly with CSV files
Bank Buddy provides customizable transaction categorization; Elbank may rely on bank-provided categories

When to use Elbank: For automated tracking of multiple bank accounts with direct data fetching and basic reporting. When to use Bank Buddy: For detailed analysis and categorization of bank statements, especially when working with CSV exports or when bank integration isn’t available or desired.

Beancount-mode

Beancount-mode is an Emacs mode for Beancount, another plain-text accounting system.

Key differences:

Beancount, like Ledger, is a full double-entry accounting system
Beancount has stricter syntax requirements than Ledger
Bank Buddy offers automatic categorization and reporting, while Beancount requires manual entry
Beancount generates sophisticated reports, but requires more setup and knowledge

When to use Beancount: For precise, auditable personal accounting with strict validation. When to use Bank Buddy: For simple spending analysis without learning accounting principles.

csv-mode and orgtbl-mode

Some users analyze financial CSV data using built-in Emacs packages like csv-mode combined with org-table functionality.

Key differences:

These are general-purpose tools that require manual customization for financial analysis
Bank Buddy provides specialized, financial-specific analysis and visualization
Bank Buddy automatically categorizes transactions based on patterns
Bank Buddy generates reports without manual processing

When to use csv/orgtbl-mode: For custom, one-off analysis of financial data. When to use Bank Buddy: For consistent, repeatable analysis of bank statements.

Roadmap

TODO	DOING	DONE
Add Paypal break down csv	Highlight bank lines not matched for iterative tweaks	Asynchronous operation
Add large sum outlays	Generate test data and unit test
Budget Tracking	Data Visualization
AI-Powered Categorization	Better gnuplot autogeneration of plots
	Custom Category Mapping

Ollama Buddy 0.12.0: User Prompt Library, File Attachments, Vision and Context Tracking

James Dyer — Fri, 23 May 2025 14:10:00 +0100

There have been quite a few updates recently. The main highlights include support for attachments, so you can push a file to the chat directly from dired for potential inclusion in your next query.

Vision support has been added for models that can handle it. If you supply the path to an image file in the chat, it will be processed. This means you can now, for example, extract text from images using models like o:gemma3:4b.

I’ve also introduced the ability to save user system prompts. If you have a favorite prompt, or have crafted one that works especially well for you, you can now save it by category and title in a simple Org format for later recall. Prompt recall now works the same way as Fabric patterns and Awesome ChatGPT prompts. This makes it much easier to display the currently used system prompt concisely in the status bar, as it will be based on the prompt title (and thus likely the role).

What else? Oh yes, I received a request for better context tracking. Now, when context is nearing full capacity, or has exceeded it, it will be indicated in the status bar!

That’s probably it for the major changes. There was also some refactoring, but you probably don’t care about that. Anyway, here is the full list of changes:

<2025-05-22 Thu> 0.12.0

Full system prompt in the status bar replaced with a more meaningful simple role title

Added system prompt metadata tracking with title, source, and timestamp registry
Implemented automatic title extraction and unified completing-read interface
Enhanced fabric/awesome prompt integration with proper metadata handling
Improved transient menu organization and org-mode formatting with folding
Added system prompt history display and better error handling for empty files
Transient menu has been simplified and reorganised

Previously, the header status bar would show truncated system prompt text like [You are a helpful assistant wh...], making it difficult to quickly identify which prompt was active. Now, the display shows meaningful role titles with source indicators:

[F:Code Reviewer] - Fabric pattern
[A:Linux Terminal] - Awesome ChatGPT prompt
[U:Writing Assistant] - User-defined prompt

The system now intelligently extracts titles from prompt content by recognizing common patterns like “You are a…”, “Act as…”, or “I want you to act as…”. When these patterns aren’t found, it generates a concise title from the first few words.

Behind the scenes, Ollama Buddy now maintains a registry of all system prompts with their titles, sources, and timestamps. This enables new features like system prompt history viewing and better organization across Fabric patterns, Awesome ChatGPT prompts, and user-defined prompts.

The result is a cleaner interface that makes it immediately clear which role your AI assistant is currently embodying, without cluttering the status bar with long, truncated text.

<2025-05-21 Wed> 0.11.1

Quite a bit of refactoring to generally make this project more maintainable and I have added a starter kit of user prompts.

Color System Reworking
- Removed all model color-related functions and variables
- Removed dependency on color.el
- Replaced with highlight-regexp and hashing to ^font-lock faces, so now using a more native built-in solutions for model colouring rather than shoe-horning in overlays.
UI Improvements
- Simplified the display system by leveraging Org mode
- Added org-mode styling for output buffers
- Added org-hide-emphasis-markers and org-hide-leading-stars settings
- Changed formatting to use Org markup instead of text properties
- Converted plain text headers to proper Org headings
- Replaced color properties with Org emphasis (bold)
History Management Updates
- Streamlined history editing functionality
- Improved model-specific history editing
- Refactored history display and navigation
System Prompts
- Added library of system prompts in these categories:
  - analysis (3 prompts)
  - coding (5 prompts)
  - creative (3 prompts)
  - documentation (3 prompts)
  - emacs (10 prompts)
  - general (3 prompts)
  - technical (3 prompts)
  - writing (3 prompts)

<2025-05-19 Mon> 0.11.0

Added user system prompts management

You can now save, load and manage system prompts
Created new transient menu for user system prompts (C-c s)
Organized prompts by categories with org-mode format storage
Supported prompt editing, listing, creation and deletion
Updated key bindings to integrate with existing functionality
Added prompts directory customization with defaults

This feature makes it easier to save, organize, and reuse your favorite system prompts when working with Ollama language models.

System prompts are special instructions that guide the behavior of language models. By setting effective system prompts, you can:

Define the AI’s role (e.g., “You are a helpful programming assistant who explains code clearly”)
Establish response formats
Set the tone and style of responses
Provide background knowledge for specific domains

The new ollama-buddy-user-prompts module organizes your system prompts in a clean, category-based system:

Save your prompts - Store effective system prompts you’ve crafted for future use
Categorize - Prompts are organized by domains like “coding,” “writing,” “technical,” etc.
Quick access - Browse and load your prompt library with completion-based selection
Edit in org-mode - All prompts are stored as org files with proper metadata
Manage with ease - Create, edit, list, and delete prompts through a dedicated transient menu

The new functionality is accessible through the updated key binding C-c s, which opens a dedicated transient menu with these options:

Save current (S) - Save your active system prompt
Load prompt (L) - Choose a previously saved prompt
Create new (N) - Start fresh with a new prompt
List all Prompts (l) - View your entire prompt library
Edit prompt (e) - Modify an existing prompt
Delete prompt (d) - Remove prompts you no longer need

If you work frequently with Ollama models, you’ve likely discovered the power of well-crafted system prompts. They can dramatically improve the quality and consistency of responses. With this new management system, you can:

Build a personal library of effective prompts
Maintain context continuity across sessions
Share prompts with teammates
Refine your prompts over time

<2025-05-14 Wed> 0.10.0

Added file attachment system for including documents in conversations

Added file attachment support with configurable file size limits (10MB default) and supported file types
Implemented session persistence for attachments in save/load functionality
Added attachment context inclusion in prompts with proper token counting
Created comprehensive attachment management commands:
- Attach files to conversations
- Show current attachments in dedicated buffer
- Detach specific files
- Clear all attachments
Added Dired integration for bulk file attachment
Included attachment menu in transient interface (C-c 1)
Updated help text to document new attachment keybindings
Enhanced context calculation to include attachment token usage

You can now seamlessly include text files, code, documentation, and more directly in your conversations with local AI models!

Simply use C-c C-a from the chat buffer to attach any file to your current conversation.

The attached files become part of your conversation context, allowing the AI to reference, analyze, or work with their contents directly.

The transient menu has also been updated with a new Attachment Menu

*File Attachments*
a Attach file
w Show attachments
d Detach file
0 Clear all attachments

Your attachments aren’t just dumped into the conversation - they’re intelligently integrated:

Token counting now includes attachment content, so you always know how much context you’re using
Session persistence means your attachments are saved and restored when you save/load conversations
File size limits (configurable, 10MB default) prevent accidentally overwhelming your context window

Managing attached files is intuitive with dedicated commands:

C-c C-w - View all current attachments in a nicely formatted org mode buffer, folded to each file
C-c C-d - Detach specific files when you no longer need them
C-c 0 - Clear all attachments at once
C-c 1 - Access the full attachment menu via a transient interface

Working in Dired? No problem! You can attach files directly from your file browser:

Mark multiple files and attach them all at once
Attach the file at point with a single command

Use the configuration as follows:

(eval-after-load 'dired
 '(progn
 (define-key dired-mode-map (kbd "C-c C-a") #'ollama-buddy-dired-attach-marked-files)))

<2025-05-12 Mon> 0.9.50

Added context size management and monitoring

Added configurable context sizes for popular models (llama3.2, mistral, qwen, etc.)
Implemented real-time context usage display in status bar
Can display in text or bar display types
Added context size thresholds with visual warnings
Added interactive commands for context management:
- ollama-buddy-show-context-info: View all model context sizes
- ollama-buddy-set-model-context-size: Manually configure model context
- ollama-buddy-toggle-context-percentage: Toggle context display
Implemented context size validation before sending prompts
Added token estimation and breakdown (history/system/current prompt)
Added keybindings: C-c $ (set context), C-c % (toggle display), C-c C (show info)
Updated status bar to show current/max context with fontification

I’ve added context window management and monitoring capabilities to Ollama Buddy!

This update helps you better understand and manage your model’s context usage, preventing errors and optimizing your conversations.

Enable it with the following:

(setq ollama-buddy-show-context-percentage t)

Usage

After implementing these changes:

Text mode: Shows 1024/4096 style display
Bar mode (default): Shows ███████░░░░ 2048 style display
Use C-c 8 to toggle between modes
The Text mode will change fontification based on your thresholds:
- Normal: regular fontification
- (85%+): underlined and bold
- (100%+): inverse video and bold
The Bar mode will just fill up as normal

The progress bar will visually represent how much of the context window you’re using, making it easier to see at a glance when you’re approaching the limit.

Implementation Details

Context Size Detection

Determining a model’s context size proved more complex than expected. While experimenting with parsing model info JSON, I discovered that context size information can be scattered across different fields. Rather than implementing a complex JSON parser (which may come later), I chose a pragmatic approach:

I created a new defcustom variable ollama-buddy-fallback-context-sizes that includes hard-coded values for popular Ollama models. The fallback mechanism is deliberately simple: substring matching followed by a sensible default of 4096 tokens.

(defcustom ollama-buddy-fallback-context-sizes
 '(("llama3.2:1b" . 2048)
 ("llama3:8b" . 4096)
 ("tinyllama" . 2048)
 ("phi3:3.8b" . 4096)
 ("gemma3:1b" . 4096)
 ("gemma3:4b" . 8192)
 ("llama3.2:3b" . 8192)
 ("llama3.2:8b" . 8192)
 ("llama3.2:70b" . 8192)
 ("starcoder2:3b" . 8192)
 ("starcoder2:7b" . 8192)
 ("starcoder2:15b" . 8192)
 ("mistral:7b" . 8192)
 ("mistral:8x7b" . 32768)
 ("codellama:7b" . 8192)
 ("codellama:13b" . 8192)
 ("codellama:34b" . 8192)
 ("qwen2.5-coder:7b" . 8192)
 ("qwen2.5-coder:3b" . 8192)
 ("qwen3:0.6b" . 4096)
 ("qwen3:1.7b" . 8192)
 ("qwen3:4b" . 8192)
 ("qwen3:8b" . 8192)
 ("deepseek-r1:7b" . 8192)
 ("deepseek-r1:1.5b" . 4096))
 "Mapping of model names to their default context sizes.
Used as a fallback when context size can't be determined from the API."
 :type '(alist :key-type string :value-type integer)
 :group 'ollama-buddy)

This approach may not be perfectly accurate for all models, but it’s sufficient for getting the core functionality working. More importantly, as a defcustom, users can easily customize these values for complete accuracy with their specific models. Users can also set context values within the chat buffer through C-c C (Show Context Information) for each individual model if desired.

This design choice allowed me to focus on the essential features without getting stuck on complex context retrieval logic.

One final thing!, if the num_ctx: Context window size in tokens is set, then that number will also be taken into consideration. An assumption will be made that the model is honouring the context size requested and will incorporated into the context calculations accordingly.

Token Estimation

For token counting, I’ve implemented a simple heuristic: each word (using string-split) is multiplied by 1.3. This follows commonly recommended approximations and works well enough in practice. While this isn’t currently configurable, I may add it as a customization option in the future.

How to Use Context Management in Practice

The C-c C (Show Context Information) command is central to this feature. Rather than continuously monitoring context size while you type (which would be computationally expensive and potentially distracting), I’ve designed the system to calculate context on-demand when you choose.

Typical Workflows

Scenario 1: Paste-and-Send Approach

Let’s say you want to paste a large block of text into the chat buffer. You can simply:

Paste your content
Press the send keybinding
If the context limit is exceeded, you’ll get a warning dialog asking whether to proceed anyway

Scenario 2: Preemptive Checking

For more control, you can check context usage before sending:

Paste your content
Run C-c C to see the current context breakdown
If the context looks too high, you have several options:
- Trim your current prompt
- Remove or simplify your system prompt
- Edit conversation history using Ollama Buddy’s history modification features
- Switch to a model with a larger context window

Scenario 3: Manage the Max History Length

Want tight control over context size without constantly monitoring the real-time display? Since conversation history is part of the context, you can simply limit ollama-buddy-max-history-length to control the total context size.

For example, when working with small context windows, set ollama-buddy-max-history-length to 1. This keeps only the last exchange (your prompt + model response), ensuring your context remains small and predictable, perfect for maintaining control without manual monitoring.

Scenario 4: Parameter num_ctx: Context window size in tokens

Simply set this parameter and off you go!

Current Status: Experimental

Given the potentially limiting nature of context management, I’ve set this feature to disabled by default.

But to enable set the following :

(setq ollama-buddy-show-context-percentage t)

This means:

Context checks won’t prevent sending prompts
Context usage won’t appear in the status line
However, calculations still run in the background, so C-c C (Show Context Information) remains functional

As the feature matures and proves its value, I may enable it by default. For now, consider it an experimental addition that users can opt into.

More Details

The status bar now displays your current context usage in real-time. You’ll see a fraction showing used tokens versus the model’s maximum context size (e.g., “2048/8192”). The display automatically updates as your conversation grows.

Context usage changes fontification to help you stay within limits:

Normal font: Normal usage (under 85%)
Bold and Underlined: Approaching limit (85-100%)
Inversed: At or exceeding limit (100%+)

Before sending prompts that exceed the context limit, Ollama Buddy now warns you and asks for confirmation. This prevents unexpected errors and helps you manage long conversations more effectively.

There are now three new interactive commands:

C-c $ - Set Model Context Size. Manually configure context sizes for custom or fine-tuned models.

C-c % - Toggle Context Display. Show or hide the context percentage in the status bar.

C-c C - Show Context Information. View a detailed breakdown of:

All model context sizes
Current token usage by category (history, system prompt, current prompt)
Percentage usage

The system estimates token counts for:

Conversation history: All previous messages
System prompts: Your custom instructions
Current input: The message you’re about to send

This gives you a complete picture of your context usage before hitting send.

The context monitoring is not enabled by default.

<2025-05-05 Mon> 0.9.44

Sorted model names alphabetically in intro message
Removed multishot writing to register name letters

For some reason, when I moved the .ollama folder to an external disk, the models returned with api/tags were inconsistent, which meant it broke consistent letter assignment. I’m not sure why this happened, but it is probably sensible to sort the models alphabetically anyway, as this has the benefit of naturally grouping together model families.

I also removed the multishot feature of writing to the associated model letter. Now that I have to accommodate more than 26 models, incorporating them into the single-letter Emacs register system is all but impossible. I suspect this feature was not much used, and if you think about it, it wouldn’t have worked anyway with multiple model shots, as the register letter associated with the model would just show the most recent response. Due to these factors, I think I should remove this feature. If someone wants it back, I will probably have to design a bespoke version fully incorporated into the ollama-buddy system, as I can’t think of any other Emacs mechanism that could accommodate this.

<2025-05-05 Mon> 0.9.43

Fix model reference error exceeding 26 models #15

Update ollama-buddy to handle more than 26 models by using prefixed combinations for model references beyond ‘z’. This prevents errors in create-intro-message when the local server hosts a large number of models.

<2025-05-03 Sat> 0.9.42

Added the following to recommended models:

qwen3:0.6b
qwen3:1.7b
qwen3:4b
qwen3:8b

and fixed pull model

<2025-05-02 Fri> 0.9.41

Refactored model prefixing again so that when using only ollama models no prefix is applied and is only applied when online LLMs are selected (for example claude, chatGPT e.t.c)

I think this makes more sense and is cleaner for I suspect the majority who may use this package are probably more interested in just using ollama models and the prefix will probably be a bit confusing.

This could be a bit of a breaking change once again I’m afraid for those ollama users that have switched and are now familiar with prefixing “o:”, sorry!

<2025-05-02 Fri> 0.9.40

Added vision support for those ollama models that can support it!

Image files are now detected within a prompt and then processed if a model can support vision processing. Here’s a quick overview of how it works:

Configuration: Users can configure the application to enable vision support and specify which models and image formats are supported. Vision support is enabled by default.
Image Detection: When a prompt is submitted, the system automatically detects any image files referenced in the prompt.
Vision Processing: If the model supports vision, the detected images are processed in relation to the defined prompt. Note that the detection of a model being vision capable is defined in ollama-buddy-vision-models and can be adjusted as required.
In addition, a menu item has been added to the custom ollama buddy menu :
```
 [I] Analyze an Image
```

When selected, it will allow you to describe a chosen image. At some stage, I may allow integration into dired, which would be pretty neat. :)

The Smallest of Productivity Gains by Instantly Opening Dired Files when isearching

James Dyer — Tue, 13 May 2025 09:20:00 +0100

If you’re an Emacs user (which I know you are), especially one who lives in dired-mode, you’re probably familiar with the quick power of isearch for finding files or directories. But if you’re like me, you might have noticed a tiny speed bump in the workflow: after finding a file or directory with isearch, you would typically have to hit <enter> to exit the search, and then <enter> again to open the entry. That’s two steps for something that feels like it should be one and this has been a very minor annoyance for me for a very long time now.

I had a little time to shave some more yak hair, so lets try and address this!

The solution I came up with was to add a bit of advice to isearch-exit, so now, when you’re in dired-mode and you use isearch to locate a file or directory, pressing <enter> will both exit the search and immediately open the file or directory, no need for a second confirmation.

Here’s the magic!

(defadvice isearch-exit (after dired-enter-directory-or-file activate)
 "In dired mode, enter directory or open file after isearch."
 (when (eq major-mode 'dired-mode)
 (let ((file (dired-get-file-for-visit)))
 (when file
 (dired-find-file)))))

The only thing I am a little worried about are the side effects, but I guess we shall see…

And another thing, now my dired navigation is one step smoother; how much time generally is it going to save me? Was it worth the effort?.

Let’s say, conservatively, that I have pressed that extra Enter 100 times each day. Each press takes, say, 150 ms, accounting for human reaction times, even though it isn’t really a reaction, more of a muscle memory response.

Let’s do the calculations! I have no idea why I’m doing this, but maybe I can validate the amount of time I spent on this for future time-saving gains. Maybe it will make me feel better about the countless hours of yak shaving I have done over many years (with Emacs, of course, although I do have a yak in the garden shed that really needs some attention!)

So, the savings are as follows:

Day: 15 seconds
Week: 105 seconds
Month: 7 minutes
Year: 1 hour 24 minutes

Well, the yearly total is probably about the amount of time I actually took to implement this, so that means in a year I will be making productivity gains! Sweeeeeeet!

Discovering Treasures in Emacs-solo

James Dyer — Wed, 07 May 2025 21:45:00 +0100

While exploring Emacs-solo, I was struck by how closely its philosophy aligned with my own Emacs-DIYer project. The parallels were sometimes uncanny, for example, we had independently chosen identical keybindings like “M-s g” for grep functionality. I had been also considering “M-s f” for my find variant and was looking for a home for recentf, potentially at “M-g r”. There were also some ideas around using other finding tools such as ripgrep and fd as a callout to some external tools and there were many other similarities.

I was particularly intrigued to see newsticker included, as I had recently adopted it as an elfeed replacement. The ace-window alternative implementation also closely mirrored my own single-defun approach.

So, with my first pass through, I have picked out the following goodies to be purloined and incorporated into Emacs-DIYer

dired icon replacements
Git gutter status overlay
Hide completion buffer when icomplete in buffer
ollama alternative directly from ansi-term

Firstly, the dired icon replacement provides visual clarity without requiring the all-the-icons packages. While perhaps not essential, it gives me a comfy feel and I think these icons significantly improve the Emacs experience, particularly for frequent dired users like myself.

I pretty much just copied the entire emacs-solo-dired-icons section but stripped out the use-package as I’m trying to keep Emacs-DIYer compatible with older versions of Emacs. This worked straight out the box (like all the other integrations) and I just needed to make sure I have the requisite font collection installed.

The git status indicator in the dired gutter was a welcome addition I hadn’t previously implemented or even considered. It provides immediate visual feedback that feels natural and intuitive, especially coming from a background of extensive version control experience.

Having used subversion for over 20 years (before transitioning to TortoiseSVN and then magit and vc), I was already accustomed to status characters like “M” indicating modified files and other single key status key definitions seem consistent to my previous experience, and isn’t it great to see them visible in dired!

In summary, this integration complements my existing modeline status indicator, along with vc and gives me both file-specific and directory-level version control visibility, noice!

I had been working on replacing corfu/company with in-buffer completion, but hadn’t solved how to hide the completion buffer when using icomplete. My settings already closely matched those in Emacs-solo, but the critical missing piece was this elegant advice:

(if icomplete-in-buffer
 (advice-add 'completion-at-point
 :after #'minibuffer-hide-completions))

Now it feels much cleaner and I might start using it rather than corfu from now on.

The final act of pilfering is to incorporate a simple ollama integration.

Before creating my Ollama Buddy package, I had explored integrating ollama through a shell and I had also come to the conclusion that using ansi-term was really the only quick solution, but I just couldn’t figure out the implementation details. However, the experience ultimately led me to take an alternative approach, writing a small implementation to interface with ollama from an Emacs buffer, which eventually gave rise to Ollama Buddy.

The Emacs-solo ansi-term solution feels surprisingly well-integrated once you become comfortable switching between line and character modes. I’ve now incorporated this as an alternative to my API-based implementation, providing two no-dependency options for local LLM access!

I plan to further explore Emacs-solo, particularly for additional vc enhancements. This first pass has already yielded valuable improvements to Emacs-DIYer, and this has been a valuable exercise to learn from another project with such similar design principles.

Ollama-Buddy 0.9.38: Unload Models, Hide AI Reasoning, and Clearly View Modified Parameters on each request

James Dyer — Thu, 01 May 2025 13:33:00 +0100

More improvements to ollama-buddy https://github.com/captainflasmr/ollama-buddy

<2025-04-29 Tue> 0.9.38

Added model unloading functionality to free system resources

Add unload capability for individual models via the model management UI
Create keyboard shortcut (C-c C-u) for quick unloading of all models
Display running model count and unload buttons in model management buffer

Large language models consume significant RAM and GPU memory while loaded. Until now, there wasn’t an easy way to reclaim these resources without restarting the Ollama server entirely. This new functionality allows you to:

Free up GPU memory when you’re done with your LLM sessions
Switch between resource-intensive tasks more fluidly
Manage multiple models more efficiently on machines with limited resources
Avoid having to restart the Ollama server just to clear memory

There are several ways to unload models with the new functionality:

Unload All Models: Press C-c C-u to unload all running models at once (with confirmation)
Model Management Interface: Access the model management interface with C-c W where you’ll find:
- A counter showing how many models are currently running
- An “Unload All” button to free all models at once
- Individual “Unload” buttons next to each running model
Quick Access in Management Buffer: When in the model management buffer, simply press u to unload all models

The unloading happens asynchronously in the background, with clear status indicators so you can see when the operation completes.

<2025-04-25 Fri> 0.9.37

Display modified parameters in token stats

Enhanced the token statistics section to include any modified parameters, providing a clearer insight into the active configurations. This update helps in debugging and understanding the runtime environment.

<2025-04-25 Fri> 0.9.36

Added Reasoning/Thinking section visibility toggle functionality

Introduced the ability to hide reasoning/thinking sections during AI responses, making the chat output cleaner and more focused on final results
Added a new customizable variable ollama-buddy-hide-reasoning (default: nil) which controls visibility of reasoning sections
Added ollama-buddy-reasoning-markers to configure marker pairs that encapsulate reasoning sections (supports multiple formats like <think></think> or —-)
Added ollama-buddy-toggle-reasoning-visibility interactive command to switch visibility on/off
Added keybinding C-c V for toggling reasoning visibility in chat buffer
Added transient menu option “V” for toggling reasoning visibility
When reasoning is hidden, a status message shows which section is being processed (e.g., “Think…” or custom marker names)
Reasoning sections are automatically detected during streaming responses
Header line now indicates when reasoning is hidden with “REASONING HIDDEN” text
All changes preserve streaming response functionality while providing cleaner output

This feature is particularly useful when working with AI models that output their “chain of thought” or reasoning process before providing the final answer, allowing users to focus on the end results while still having the option to see the full reasoning when needed.

Ollama-Buddy 0.9.35: Grok, Gemini Integration and Enhanced Sessions

James Dyer — Thu, 24 Apr 2025 09:20:00 +0100

Several improvements in the latest Ollama Buddy updates (versions 0.9.21 through 0.9.35):

🎉 New AI Integrations with Grok and Gemini

Google’s Gemini is now complementing existing support for Claude, ChatGPT (OpenAI), and Ollama models. Setting up is straightforward and consistent with other integrations.
Just like the existing integrations, Grok can now be easily configured with your API key.

🔗 Improved Remote LLM Architecture

LLM internal decoupling, making Ollama Buddy’s core logic independent from any specific remote LLM. Each LLM integration now functions as a self-contained extension, significantly simplifying future additions and maintenance.

🎯 Standardized Model Prefixing

Now there are more remote LLMs into the mix I thought it was probably time to more clearly distinguish between model collections, so I have defined the following prefixes:

Ollama: o:
ChatGPT: a:
Claude: c:
Gemini: g:
Grok: k:

This change helps ensure clarity, especially when recalling previous sessions. Note: existing session files will need the Ollama prefix (o:) added manually if you encounter issues recalling older sessions.

💾 Enhanced Session Management

Saving session now makes a little more sense and is more consistent:

Automatic timestamped session names (you can still set your own).
Sessions now also save as org files alongside the original elisp files, allowing for richer recall and easy inspection later.
The current session name appears dynamically in your modeline, offering quick context.

🛠️ Additional Improvements

UTF-8 encoding fixes for remote LLM stream responses.
Refactored history and model management so all the latest models are available for selection. This is currently most relevant for remote LLMs which often change their model selection.
History view/edit functionality merged into one keybinding

and here is the change history

<2025-04-21 Mon> 0.9.35

Added Grok support

Integration is very similar to other remote AIs:

(use-package ollama-buddy
 :bind
 ("C-c o" . ollama-buddy-menu)
 ("C-c O" . ollama-buddy-transient-menu-wrapper)
 :custom
 (ollama-buddy-grok-api-key
 (auth-source-pick-first-password :host "ollama-buddy-grok" :user "apikey"))
 :config
 (require 'ollama-buddy-grok nil t))

<2025-04-20 Sun> 0.9.33

Fixed utf-8 encoding stream response issues from remote LLMs.

<2025-04-19 Sat> 0.9.32

Finished the remote LLM decoupling process, meaning that the core ollama-buddy logic is now not dependent on any remote LLM, and each remote LLM package is self-contained and functions as a unique extension.

<2025-04-18 Fri> 0.9.31

Refactored model prefixing logic and cleaned up

Standardized model prefixing by introducing distinct prefixes for Ollama (o:), OpenAI (a:), Claude (c:), and Gemini (g:) models.
Centralized functions to get full model names with prefixes across different model types.
Removed redundant and unused variables related to model management.

Note that there may be some breaking changes here especially regarding session recall as all models will now have a prefix to uniquely identify their type. For ollama recall, just edit the session files to prepend the ollama prefix of “o:”

<2025-04-17 Thu> 0.9.30

Added Gemini integration!

As with the Claude and ChatGPT integration, you will need to add something similar to them in your configuration. I currently have the following set up to enable access to the remote LLMs:

(use-package ollama-buddy
 :bind
 ("C-c o" . ollama-buddy-menu)
 ("C-c O" . ollama-buddy-transient-menu-wrapper)
 :custom
 (ollama-buddy-openai-api-key
 (auth-source-pick-first-password :host "ollama-buddy-openai" :user "apikey"))
 (ollama-buddy-claude-api-key
 (auth-source-pick-first-password :host "ollama-buddy-claude" :user "apikey"))
 (ollama-buddy-gemini-api-key
 (auth-source-pick-first-password :host "ollama-buddy-gemini" :user "apikey"))
 :config
 (require 'ollama-buddy-openai nil t)
 (require 'ollama-buddy-claude nil t)
 (require 'ollama-buddy-gemini nil t))

Also with the previous update all the latest model names will be pulled, so there should be a full comprehensive list for each of the main remote AI LLMs!

<2025-04-16 Wed> 0.9.23

Refactored history and model management for remote LLMs

Now pulling in latest model list for remote LLMs (so now ChatGPT 4.1 is available!)
Removed redundant history and model management functions from ollama-buddy-claude.el and ollama-buddy-openai.el. Replaced them with shared implementations to streamline code and reduce duplication

<2025-04-15 Tue> 0.9.22

Enhanced session management

Refactored ollama-buddy-sessions-save to autogenerate session names using timestamp and model.
Improved session saving/loading by integrating org file handling.
Updated mode line to display current session name dynamically.

Several improvements to session management, making it more intuitive and efficient for users. Here’s a breakdown of the new functionality:

When saving a session, Ollama Buddy now creates a default name using the current timestamp and model name, users can still provide a custom name if desired.

An org file is now saved alongside the original elisp session file. This allows for better session recall as all interactions will be pulled back with the underlying session parameters still restored as before. There is an additional benefit in not only recalling precisely the session and any additional org interactions but also quickly saving to an org file for potential later inspection. Along with the improved autogenerated session name, this means it is much faster and more intuitive to save a snapshot of the current chat interaction.

The modeline now displays the current session name!

<2025-04-11 Fri> 0.9.21

Add history edit/view toggle features, so effectively merging the former history display into the history edit functionality.

Flex Matching with isearch

James Dyer — Thu, 17 Apr 2025 09:00:00 +0100

I’m having issues with isearch!

I’ve been using fido-mode for a while now (I’m one of those weirdos who transitioned from the Vertico/Marginalia/Orderless stack back to an Emacs built-in) and have become accustomed to the flexible matching that fido offers. For example, I often shorten commands to find them, such as:

It is very common for me to search in a buffer for strings that contain a dash (especially now I am doing a lot more elisp programming), and I keep instinctively fido-shortening the search (so searching without the dash). Each time, isearch says no (or fails), so I have to awkwardly reach out for the “-” and go back and perform the search again.

What if there was a more flexible way to perform an in-buffer search? Well, of course, there is, and that is the isearch-regexp variants. I have seen some people just binding this to their main isearch because, why not? Most of the time, the search will be identical, and there is always the opportunity for a more flexible search using “.*”.

Let’s run an example. I would like to search for the first occurrence of use-package in my config. Let’s see how many keys we can get down to for an efficient search and how easy ergonomically they are to get to (excluding the possibility of some annoyingly similar matching lines in the config)

Firstly, let’s try isearch - you would have to type up to at least “use-pa” (probably).

Now for isearch-regex - you would type “us.*p” (probably) or of course just the same as isearch, so “use-pa”. This is better but a bit awkward to access the “*” and you would have to be quite aware of what you were searching for and the rough split of words.

If this were translated into a form of fido search, you would type at least “usep” (probably), a similar number of characters, but no awkward punctuation (so faster to type) and the find is more flexible and for me now, more familiar.

As far as I’m aware, by default fido uses some form of flex matching (but not quite flex), which has been good enough for me for a while now. So, how do I get this form of matching using isearch and it being in-buffer?

After a little investigation, there are packages out there in Emacs-land for some fuzzy searching, and the most relevant seemed to be flex-isearch. I’m not sure I quite got it working for me, but looking through the code, I thought I could distil some concepts into simple defuns. I learned that you can actually slot any search function at the backend of isearch, so let’s transform a normal search into something on steroids that would give us a flexible search, fido style!

(defvar flex-isearch-group-size 3
 "Number of initial characters to group together for more accurate flex searching.")

(defun flex-isearch-regexp-compile (string)
 "Convert a search string to a more intelligent flex-matching regexp.
The first `flex-isearch-group-size` characters are grouped together for more accurate matching."
 (let* ((parts (split-string string " " t))
 (compile-part
 (lambda (part)
 (let ((grouped (substring part 0 (min flex-isearch-group-size (length part))))
 (rest (substring part (min flex-isearch-group-size (length part)))))
 (concat
 (regexp-quote grouped)
 (mapconcat
 (lambda (char)
 (let ((c (char-to-string char)))
 (cond
 ((and (>= char ?A) (<= char ?Z))
 (concat "[^" c "\n]*" c))
 ((and (>= char ?a) (<= char ?z))
 (concat "[^" c (upcase c) "\n]*[" c (upcase c) "]"))
 (t
 (concat "[^" (regexp-quote c) "\n]*" (regexp-quote c))))))
 rest
 "")
 "[^-_[:alnum:]\n]*")))))
 (concat
 "\\b"
 (mapconcat compile-part parts "[^-_[:alnum:]\n]+"))))

(defun flex-isearch-search-fun ()
 "Return the appropriate search function for flex searching."
 (if isearch-forward 'flex-isearch-forward 'flex-isearch-backward))

(defun flex-isearch-forward (string &optional bound noerror count)
 "Flex search forward for STRING."
 (let ((regexp (flex-isearch-regexp-compile string)))
 (re-search-forward regexp bound t)))

(defun flex-isearch-backward (string &optional bound noerror count)
 "Flex search backward for STRING."
 (let ((regexp (flex-isearch-regexp-compile string)))
 (re-search-backward regexp bound t)))

(setq isearch-search-fun-function 'flex-isearch-search-fun)

With my first attempt at this, the search at times seemed to settle on more candidates than I would have liked, but I thought, “I generally always know at least the first 2 or 3 characters that I’m searching for, at which point things get a little fuzzy” (pun intended). So, can I group the first few letters as part of the search, thus narrowing down the candidate list?

The answer is yes, yes I can.

The code above is a first attempt and with all these things, I shall play around with it and see if it works for me. At the moment, this seems to give me a more fido-iish feel when searching in-buffer with isearch, and no awkward search punctuation in sight!. So, using the examples above I can now find “use-package” in my config with a simple “usep”.

I shall report back in a later post to see if it has settled into my workflow, or whether there is an annoyance that I just cannot put up with so it will have to be discarded, along with my other myriad of Emacs experiments!

Ollama-Buddy 0.9.20: Curated AI Prompting with Awesome ChatGPT Prompts

James Dyer — Wed, 09 Apr 2025 13:43:00 +0100

Added ollama-buddy-awesome.el to integrate Awesome ChatGPT Prompts.

ollama-buddy-awesome is an ollama-buddy extension that integrates the popular Awesome ChatGPT Prompts repository, allowing you to leverage hundreds of curated prompts for various tasks and roles right within your Emacs environment, I thought that since I have integrated the fabric set of curated prompts, so then why not these!

There is a video demonstration here : https://www.youtube.com/watch?v=5A4bTvjmPeo

Key Features

Seamless Sync: Automatically fetch the latest prompts from the GitHub repository, ensuring you always have access to the most up-to-date collection.
Smart Categorization: Prompts are intelligently categorized based on their content, making it easy to find the perfect prompt for your task.
Interactive Selection: Choose prompts through Emacs’ familiar completion interface, with category and title information for quick identification.
Effortless Application: Apply selected prompts as system prompts in ollama-buddy with a single command, streamlining your AI-assisted workflow.
Prompt Management: List available prompts, preview their content, and display full prompt details on demand.

Getting Started

To access the Awesome ChatGPT prompts, just select the transient menu as normal and select “[a] Awesome ChatGPT Prompts”, this will fetch the prompts and prepare everything for your first use and give you a transient menu as follows:

Actions
[s] Send with Prompt
[p] Set as System Prompt
[l] List All Prompts
[c] Category Browser
[S] Sync Latest Prompts
[q] Back to Main Menu

Now available are a vast array of role-based and task-specific prompts, enhancing your ollama-buddy interactions in Emacs!

Ollama-Buddy 0.9.17: Claude Support, Asynchronous Operations and Responses to Registers

James Dyer — Wed, 02 Apr 2025 17:15:00 +0100

I’ve added experimental support for Claude AI, aligning its implementation with my support for ChatGPT, to pave the way for external AI templating which should make it easier to integrate new models in the future. Like the ChatGPT implementation, it doesn’t stream tokens in real time but instead outputs the final result all at once. However, after testing it further, I’m actually starting to prefer it. The response speed is so fast that not seeing a real-time “Typing” indicator isn’t a big deal. I think that streaming feels more relevant for local LLMs running through ollama, where token generation is slower, making real-time output more useful.

Secondly, the Texinfo manual for this package now magically installs itself when pulling from MELPA. I fluked this!, I just thought it was sensible to create a docs directory and then plonked an info file there. After looking into it, I found that MELPA performs some extra processing when handling Emacs documentation. It automatically scans common documentation directories like docs and grabs the .info file, pretty neat! This means you can now browse ollama-buddy’s functionality directly through info.

Next up, I realized I wasn’t efficiently handling ollama model operations like delete, pull, and copy. I was currently process-calling ollama and passing through arguments as if I was on the command line. This was functional, but wasn’t ideal and wasn’t stimulating the ollama API for these operations correctly, or even at all. After reassessing my design, I came to the realization that I was in fact using four different methods to communicate with ollama:

curl
Direct process calls
url.el
make-network-process

At first, I leaned on curl since it was straightforward and matched the official ollama examples. My approach with a project such as this is generally to get things working quickly and then refine/iterate later. However, once I had a solid design (and design principles!), I wanted to eliminate external dependencies like curl. This lead me to explore url.el, but initially I couldn’t seem to get my head round it / get it working - and I decided to go for the nuclear option of make-network-process for network-level flexibility. Later, I revisited url.el for Claude and ChatGPT support, rewriting the implementation to use url-retrieve, but decided generally to keep make-network-process for ollama interactions as it was still Emacs built-in and actually I’m more familiar with the lower level network concepts as having wrestled with them over many years at work.

Anyway, back to the stimulating of the ollama API for model operations.

I considered leveraging my existing url.el based ollama-buddy--make-request function, but quickly realized it used url-request-data, which blocks execution. This wasn’t an issue for quick requests like model info or tags (although could be), but for long-running tasks like model pulls and general model operations it risked freezing Emacs!

Switching to url-retrieve solved this, as it runs asynchronously, however, url-retrieve only triggers its callback at the end of the request, making real-time progress tracking difficult. To address this, I implemented run-with-timer, ensuring persistent status updates in the header-line which now allows for multiple operations, including pull, copy, delete, even simultaneously.

Now that I’m using ollama-buddy as my primary Emacs AI assistant, I’m refining my AI workflow. Since my design is centered around the chat buffer, all interactions and outputs end up there. But what about quick tasks like proofreading text or refactoring code? Ideally, I want a workflow that aligns with ollama-buddy’s principles, meaning no direct in-buffer edits (though future me might change their mind!).

For example, if I want to tighten a rambling paragraph (is this one? :), I currently send it via the custom menu to the chat buffer with a proofreading tag. However, retrieving the output requires jumping to the chat buffer, copying it, switching back, deleting the original, and then pasting the revision - too many steps.

To streamline this, I’ve now implemented a feature that writes the latest response to a customizable register, this way, I can simply delete the original text and insert the improved version without extra navigation.

Note: I have remapped the insert-register default keybinding of C-x r i to M-a, as by default I am writing to register ?a and M-a a seems more comfortable.

<2025-04-01 Tue> 0.9.17

Added link to ollama-buddy info manual from the chat buffer and transient menu as MELPA has now picked it up and installed it!

<2025-03-28 Fri> 0.9.16

Added ollama-buddy-fix-encoding-issues to handle text encoding problems.
Refactored and streamline fabric pattern description handling.
Removed unused fabric pattern categories to enhance maintainability.

<2025-03-28 Fri> 0.9.15

Implement asynchronous operations for model management
- Introduce non-blocking API requests for fetching, copying, and deleting models
Add caching mechanisms to improve efficiency
- Cache model data to reduce redundant API calls
- Manage cache expiration with timestamps and time-to-live settings
Update status line to reflect ongoing background operations
Ensure smooth user interaction by minimizing wait times and enhancing performance

<2025-03-26 Wed> 0.9.13

Added automatic writing of last response to a register
Added M-r to search through prompt history

I was just thinking about a general workflow aspect and that is getting responses out of the ollama-buddy chat buffer. Of course if you are already there then it will be easier, but even then the latest prompt, which is probably the one you are interested in will still have to be copied to the kill ring.

This issue is even more pronounced when you are sending text from other buffers to the chat.

So, the solution I have put in place is to always write the last response to a register of your choice. I always think registers are an underused part of Emacs, I already have repurposed them for the multishot, so why not always make the last response available.

For example, you want to proofread a sentence, you can mark the text, send to the chat using the custom menu to proofread then the response will be available in maybe register “a”. The chat buffer will be brought up if not already visible so you can validate the output, then pop back to your buffer, delete the paragraph and insert the register “a”?, maybe. I am going to put this in as I suspect no-one uses registers anyway and if they do, they can push the response writing register away using ollama-buddy-default-register, I don’t think this will do any harm, and actually it is something I may starting using more often.

As a side note, I also need to think about popping into the chat buffer with a buffer text push to the chat, should I do it?, not sure yet, still getting to grips with the whole workflow aspect, so will need a little more time to see what works.

Also as a side note to this ramble, the general register prefix is annoyingly long C-x r i <register> so I have rebound in my config to M-a, as I never want to go back a sentence and also if I just write to the default “a” register then it feels ergonomically fast.

<2025-03-25 Tue> 0.9.12

Added experimental Claude AI support!
removed curl and replaced with url.el for online AI integration

A very similar implementation as for ChatGPT.

To activate, set the following:

(require 'ollama-buddy-claude nil t)
(ollama-buddy-claude-api-key "<extremely long key>")

Ollama-Buddy 0.9.11: Experimental ChatGPT Integration, Customizable Streaming and Texinfo documentation

James Dyer — Tue, 25 Mar 2025 10:00:00 +0000

This week in ollama-buddy updates, I have mostly been experimenting with ChatGPT integration! Yes, it is not a local LLM, so not ollama, hence entirely subverting the whole notion and fundamental principles of this package! This I know, and I don’t care; I’m having fun. I use ChatGPT and would rather use it in Emacs through the now-familiar ollama-buddy framework, so why not? I’m also working on Claude integration too.

My original principles of a no-config Emacs ollama integration still hold true, as by default, you will only see ollama models available. But with a little tweak to the configuration, with a require here and an API key there, you can now enable communication with an online AI. At the moment, I use Claude and ChatGPT, but if I can get Claude working, I might think about just adding in a basic template framework to easily slot in others. At the moment, there is a little too much internal ollama-buddy faffing to incorporate these external AIs into the main package, but I’m sure I can figure out a way to accommodate separate elisp external AIs.

In other ollama-buddy news, I have now added support for the stream variable in the ollama API. By default, I had streaming on, and I guess why wouldn’t you? It is a chat, and you would want to see “typing” or tokens arriving as they come in?. But to support more of the API, you can toggle it on and off, so if you want, you can sit there and wait for the response to arrive in one go and maybe it can be less distracting (and possibly more efficient?).

Just a note back on the topic of online AI offerings: to simplify those integrations, I just disabled streaming for the response to arrive in one shot. Mainly, I just couldn’t figure out the ChatGPT streaming, and for an external offering, I wasn’t quite willing to spend more time on it, and due to the speed of these online behemoths, do you really need to see each token come in as it arrives?

Oh, there is something else too, something I have been itching to do for a while now, and that is to write a Texinfo document so a manual can be viewed in Emacs. Of course, this being an AI-based package, I fed in my ollama-buddy files and got Claude to generate one for me (I have a baby and haven’t the time!). Reading through it, I think it turned out pretty well :) It hasn’t been made automatically available on MELPA yet, as I need to tweak the recipe, but you can install it for yourself.

Anyways, see below for the changelog gubbins:

<2025-03-24 Mon> 0.9.11

Added the ability to toggle streaming on and off

Added customization option to enable/disable streaming mode
Implemented toggle function with keybindings (C-c x) and transient menu option
Added streaming status indicator in the modeline

The latest update introduces the ability to toggle between two response modes:

Streaming mode (default): Responses appear token by token in real-time, giving you immediate feedback as the AI generates content.
Non-streaming mode: Responses only appear after they’re fully generated, showing a “Loading response…” placeholder in the meantime.

While watching AI responses stream in real-time is often helpful, there are situations where you might prefer to see the complete response at once:

When working on large displays where the cursor jumping around during streaming is distracting
When you want to focus on your work without the distraction of incoming tokens until the full response is ready

The streaming toggle can be accessed in several ways:

Use the keyboard shortcut C-c x
Press x in the transient menu

Set the default behaviour through customization:

 (setq ollama-buddy-streaming-enabled nil) ;; Disable streaming by default

The current streaming status is visible in the modeline indicator, where an “X” appears when streaming is disabled.

<2025-03-22 Sat> 0.9.10

Added experimental OpenAI support!

Yes, that’s right, I said I never would do it, and of course, this package is still very much ollama-centric, but I thought I would just sneak in some rudimentary ChatGPT support, just for fun!

It is a very simple implementation, I haven’t managed to get streaming working, so Emacs will just show “Loading Response…” as it waits for the response to arrive. It is asynchronous, however, so you can go off on your Emacs day while it loads (although being ChatGPT, you would think the response would be quite fast!)

By default, OpenAI/ChatGPT will not be enabled, so anyone wanting to use just a local LLM through ollama can continue as before. However, you can now sneak in some experimental ChatGPT support by adding the following to your Emacs config as part of the ollama-buddy set up.

(require 'ollama-buddy-openai nil t)
(setq ollama-buddy-openai-api-key "<big long key>")

and you can set the default model to ChatGPT too!

(setq ollama-buddy-default-model "GPT gpt-4o")

With this enabled, chat will present a list of ChatGPT models to choose from. The custom menu should also now work with chat, so from anywhere in Emacs, you can push predefined prompts to the ollama buddy chat buffer now supporting ChatGPT.

There is more integration required to fully incorporate ChatGPT into the ollama buddy system, like token rates and history, etc. But not bad for a first effort, methinks!

Here is my current config, now mixing ChatGPT with ollama models:

(use-package ollama-buddy
 :bind
 ("C-c o" . ollama-buddy-menu)
 ("C-c O" . ollama-buddy-transient-menu-wrapper)
 :custom
 (ollama-buddy-openai-api-key "<very long key>")
 (ollama-buddy-default-model "GPT gpt-4o")
 :config
 (require 'ollama-buddy-openai nil t)
 (ollama-buddy-update-menu-entry
 'refactor-code :model "qwen2.5-coder:7b")
 (ollama-buddy-update-menu-entry
 'git-commit :model "qwen2.5-coder:3b")
 (ollama-buddy-update-menu-entry
 'describe-code :model "qwen2.5-coder:3b")
 (ollama-buddy-update-menu-entry
 'dictionary-lookup :model "llama3.2:3b")
 (ollama-buddy-update-menu-entry
 'synonym :model "llama3.2:3b")
 (ollama-buddy-update-menu-entry
 'proofread :model "GPT gpt-4o")
 (ollama-buddy-update-menu-entry
 'custom-prompt :model "deepseek-r1:7b"))

<2025-03-22 Sat> 0.9.9

Added texinfo documentation for future automatic installation through MELPA and created an Emacs manual.

If you want to see what the manual would look like, just download the docs directory from github, cd into it, and run:

make
sudo make install-docs

Then calling up info C-h i and ollama buddy will be present in the Emacs menu, or just select m and search for Ollama Buddy

For those interested in the manual, I have converted it into html format, which is accessible here:

/tags/ollama-buddy/

It has been converted using the following command:

makeinfo --html --no-split ollama-buddy.texi -o ollama-buddy.html
pandoc -f html -t org -o ollama-buddy.org ollama-buddy.html

<2025-03-20 Thu> 0.9.9

Intro message with model management options (select, pull, delete) and option for recommended models to pull

Enhance model management and selection features
Display models available for download but not yet pulled

Ollama-Buddy 0.9.8: Transient Menu, Model Managing, GGUF Import, fabric Prompts and History Editing

James Dyer — Wed, 19 Mar 2025 16:08:00 +0000

This week in ollama-buddy updates, I have been continuing on the busy bee side of things.

The headlines are :

Transient menu - yes, I know I said I would never do it, but, well I did and as it turns out I kinda quite like it and works especially well when setting parameters.
Support for fabric prompts presets - mainly as I thought generally user curated prompts was a pretty cool idea, and now I have system prompts implemented it seemed like a perfect fit. All I needed to do was to pull the patterns directory and then parse accordingly, of course Emacs is good at this.
GGUF import - I don’t always pull from ollama’s command line, sometimes I download a GGUF file, it is a bit of a process to import to ollama, create a model file, run a command, e.t.c, but now you can import from within dired!
More support for the ollama API - includes model management, so pulling, stopping, deleting and more!
Conversation history editing - as I store the history in a hash table, I can easily just display an alist, and editing can leverage the sexp usual keybindings and then load back in to the variable.
Parameter profiles - When implementing the transient menu I thought it might be fun to try parameter profiles where a set of parameters can be applied in a block for each preset.

And now for the detail, version by version…

<2025-03-19 Wed> 0.9.8

Added model management interface to pull and delete models

Introduced `ollama-buddy-manage-models` to list and manage models.
Added actions for selecting, pulling, stopping, and deleting models.

You can now manage your Ollama models directly within Emacs with ollama-buddy

With this update, you can now:

Browse Available Models – See all installed models at a glance.
Select Models Easily – Set your active AI model with a single click.
Pull Models from Ollama Hub – Download new models or update existing ones.
Stop Running Models – Halt background processes when necessary.
Delete Unused Models – Clean up your workspace with ease.
Open the Model Management Interface Press C-c W to launch the new Model Management buffer or through the transient menu.
Manage Your Models
- Click on a model to select it.
- Use “Pull” to fetch models from the Ollama Hub.
- Click “Stop” to halt active models.
- Use “Delete” to remove unwanted models.
Perform Quick Actions
- g → Refresh the model list.
- i → Import a GGUF model file.
- p → Pull a new model from the Ollama Hub.

When you open the management interface, you get a structured list like this:

Ollama Models Management
=======================
Current Model: mistral:7b
Default Model: mistral:7b
Available Models:
[ ] llama3.2:1b Info Pull Delete
[ ] starcoder2:3b Info Pull Delete
[ ] codellama:7b Info Pull Delete
[ ] phi3:3.8b Info Pull Delete
[x] llama3.2:3b Info Pull Delete Stop
Actions:
[Import GGUF File] [Refresh List] [Pull Model from Hub]

Previously, managing Ollama models required manually running shell commands. With this update, you can now do it all from Emacs, keeping your workflow smooth and efficient!

<2025-03-19 Wed> 0.9.7

Added GGUF file import and Dired integration

Import GGUF Models into Ollama from dired with the new ollama-buddy-import-gguf-file function. In dired just navigate to your file and press C-c i or M-x ollama-buddy-import-gguf-file to start the import process. This eliminates the need to manually input file paths, making the workflow smoother and faster.

The model will then be immediately available in the ollama-buddy chat interface.

<2025-03-18 Tue> 0.9.6

Added a transient menu containing all commands currently presented in the chat buffer
Added fabric prompting support, see https://github.com/danielmiessler/fabric
Moved the presets to the top level so they will be present in the package folder

Ollama Buddy now includes a transient-based menu system to improve usability and streamline interactions. Yes, I originally stated that I would never do it, but I think it compliments my crafted simple textual menu and the fact that I have now defaulted the main chat interface to a simple menu.

This can give the user more options for configuration, they can use the chat in advanced mode where the keybindings are presented in situ, or a more minimal basic setup where the transient menu can be activated. For my use-package definition I current have the following set up, with the two styles of menus sitting alongside each other :

 :bind
 ("C-c o" . ollama-buddy-menu)
 ("C-c O" . ollama-buddy-transient-menu)

The new menu provides an organized interface for accessing the assistant’s core functions, including chat, model management, roles, and Fabric patterns. This post provides an overview of the features available in the Ollama Buddy transient menus.

Yes that’s right also fabric patterns!, I have decided to add in auto syncing of the patterns directory in https://github.com/danielmiessler/fabric

Simply I pull the patterns directory which contain prompt guidance for a range of different topics and then push them through a completing read to set the ollama-buddy system prompt, so a special set of curated prompts can now be applied right in the ollama-buddy chat!

Anyways, here is a description of the transient menu system.

The transient menu in Ollama Buddy leverages Emacs’ transient.el package (the same technology behind Magit’s popular interface) to create a hierarchical, discoverable menu system. This approach transforms the user experience from memorizing numerous keybindings to navigating through logical groups of commands with clear descriptions.

The main transient menu can be accessed with the keybinding C-c O when in an Ollama Buddy chat buffer. You can also call it via M-x ollama-buddy-transient-menu from anywhere in Emacs.

When called, the main transient menu appears at the bottom of your Emacs frame, organized into logical sections with descriptive prefixes. Here’s what you’ll see:

|o(Y)o| Ollama Buddy
[Chat] [Prompts] [Model] [Roles & Patterns]
o Open Chat l Send Region m Switch Model R Switch Roles
O Commands s Set System Prompt v View Model Status E Create New Role
RET Send Prompt C-s Show System i Show Model Info D Open Roles Directory
h Help/Menu r Reset System M Multishot f Fabric Patterns
k Kill/Cancel b Ollama Buddy Menu
[Display Options] [History] [Sessions] [Parameters]
A Toggle Interface Level H Toggle History N New Session P Edit Parameter
B Toggle Debug Mode X Clear History L Load Session G Display Parameters
T Toggle Token Display V Display History S Save Session I Parameter Help
U Display Token Stats J Edit History Q List Sessions K Reset Parameters
C-o Toggle Markdown->Org Z Delete Session F Toggle Params in Header
c Toggle Model Colors p Parameter Profiles
g Token Usage Graph

This visual layout makes it easy to discover and access the full range of Ollama Buddy’s functionality. Let’s explore each section in detail.

Chat Section

This section contains the core interaction commands:

Open Chat (o): Opens the Ollama Buddy chat buffer
Commands (O): Opens a submenu with specialized commands
Send Prompt (RET): Sends the current prompt to the model
Help/Menu (h): Displays the help assistant with usage tips
Kill/Cancel Request (k): Cancels the current ongoing request

Prompts Section

These commands help you manage and send prompts:

Send Region (l): Sends the selected region as a prompt
Set System Prompt (s): Sets the current prompt as a system prompt
Show System Prompt (C-s): Displays the current system prompt
Reset System Prompt (r): Resets the system prompt to default
Ollama Buddy Menu (b): Opens the classic menu interface

Model Section

Commands for model management:

Switch Model (m): Changes the active LLM
View Model Status (v): Shows status of all available models
Show Model Info (i): Displays detailed information about the current model
Multishot (M): Sends the same prompt to multiple models

Roles & Patterns Section

These commands help manage roles and use fabric patterns:

Switch Roles (R): Switch to a different predefined role
Create New Role (E): Create a new role interactively
Open Roles Directory (D): Open the directory containing role definitions
Fabric Patterns (f): Opens the submenu for Fabric patterns

When you select the Fabric Patterns option, you’ll see a submenu like this:

Fabric Patterns (42 available, last synced: 2025-03-18 14:30)
[Actions] [Sync] [Categories] [Navigation]
s Send with Pattern S Sync Latest u Universal Patterns q Back to Main Menu
p Set as System P Populate Cache c Code Patterns
l List All Patterns I Initial Setup w Writing Patterns
v View Pattern Details a Analysis Patterns

Display Options Section

Commands to customize the display:

Toggle Interface Level (A): Switch between basic and advanced interfaces
Toggle Debug Mode (B): Enable/disable JSON debug information
Toggle Token Display (T): Show/hide token usage statistics
Display Token Stats (U): Show detailed token usage information
Toggle Markdown->Org (C-o): Enable/disable conversion to Org format
Toggle Model Colors (c): Enable/disable model-specific colors
Token Usage Graph (g): Display a visual graph of token usage

History Section

Commands for managing conversation history:

Toggle History (H): Enable/disable conversation history
Clear History (X): Clear the current history
Display History (V): Show the conversation history
Edit History (J): Edit the history in a buffer

Sessions Section

Commands for session management:

New Session (N): Start a new session
Load Session (L): Load a saved session
Save Session (S): Save the current session
List Sessions (Q): List all available sessions
Delete Session (Z): Delete a saved session

Parameters Section

Commands for managing model parameters:

Edit Parameter (P): Opens a submenu to edit specific parameters
Display Parameters (G): Show current parameter settings
Parameter Help (I): Display help information about parameters
Reset Parameters (K): Reset parameters to defaults
Toggle Params in Header (F): Show/hide parameters in header
Parameter Profiles (p): Opens the parameter profiles submenu

When you select the Edit Parameter option, you’ll see a comprehensive submenu of all available parameters:

Parameters
[Generation] [More Generation] [Mirostat]
t Temperature f Frequency Penalty M Mirostat Mode
k Top K s Presence Penalty T Mirostat Tau
p Top P n Repeat Last N E Mirostat Eta
m Min P x Stop Sequences
y Typical P l Penalize Newline
r Repeat Penalty
[Resource] [More Resource] [Memory]
c Num Ctx P Num Predict m Use MMAP
b Num Batch S Seed L Use MLOCK
g Num GPU N NUMA C Num Thread
G Main GPU V Low VRAM
K Num Keep o Vocab Only
[Profiles] [Actions]
d Default Profile D Display All
a Creative Profile R Reset All
e Precise Profile H Help
A All Profiles F Toggle Display in Header
q Back to Main Menu

Parameter Profiles

Ollama Buddy includes predefined parameter profiles that can be applied with a single command. When you select “Parameter Profiles” from the main menu, you’ll see:

Parameter Profiles
Current modified parameters: temperature, top_k, top_p
[Available Profiles]
d Default
c Creative
p Precise
[Actions]
q Back to Main Menu

Commands Submenu

The Commands submenu provides quick access to specialized operations:

Ollama Buddy Commands
[Code Operations] [Language Operations] [Pattern-based] [Custom]
r Refactor Code l Dictionary Lookup f Fabric Patterns C Custom Prompt
d Describe Code s Synonym Lookup u Universal Patterns m Minibuffer Prompt
g Git Commit Message p Proofread Text c Code Patterns
[Actions]
q Back to Main Menu

Direct Keybindings

For experienced users who prefer direct keybindings, all transient menu functions can also be accessed through keybindings with the prefix of your choice (or C-c O when in the chat minibuffer) followed by the key shown in the menu. For example:

C-c O s - Set system prompt
C-c O m - Switch model
C-c O P - Open parameter menu

Customization

The transient menu can be customized by modifying the transient-define-prefix definitions in the package. You can add, remove, or rearrange commands to suit your workflow.

<2025-03-17 Mon> 0.9.5

Added conversation history editing

Added functions to edit conversation history (ollama-buddy-history-edit, ollama-buddy-history-save, etc.).
Updated ollama-buddy-display-history to support history editing.
Added keybinding C-c E for history editing.

Introducing conversation history editing!!

Key Features

Now, you can directly modify past interactions, making it easier to refine and manage your ollama-buddy chat history.

Previously, conversation history was static, you could view it but not change it. With this update, you can now:

Edit conversation history directly in a buffer.
Modify past interactions for accuracy or clarity.
Save or discard changes with intuitive keybindings (C-c C-c to save, C-c C-k to cancel).
Edit the history of all models or a specific one.

Simply use the new command C-c E to open the conversation history editor. This will display your past interactions in an editable format (alist). Once you’ve made your changes, press C-c C-c to save them back into Ollama Buddy’s memory.

and with a universal argument you can leverage C-c E to edit an individual model.

<2025-03-17 Mon> 0.9.1

New simple basic interface is available.

As this package becomes more advanced, I’ve been adding more to the intro message, making it increasingly cluttered. This could be off-putting for users who just want a simple interface to a local LLM via Ollama.

Therefore I have decided to add a customization option to simplify the menu.

Note: all functionality will still be available through keybindings, so just like Emacs then! :)

Note: some could see this initially as a breaking change as the intro message will look different, but rest assured all the functionality is still there (just to re-emphasize), so if you have been using it before and want the original functionality/intro message, just set :

(setq ollama-buddy-interface-level 'advanced)

(defcustom ollama-buddy-interface-level 'basic
 "Level of interface complexity to display.
'basic shows minimal commands for new users.
'advanced shows all available commands and features."
 :type '(choice (const :tag "Basic (for beginners)" basic)
 (const :tag "Advanced (full features)" advanced))
 :group 'ollama-buddy)

By default the menu will be set to Basic, unless obviously set explictly in an init file. Here is an example of the basic menu:

*** Welcome to OLLAMA BUDDY
#+begin_example
___ _ _ n _ n ___ _ _ _ _
| | | |__._|o(Y)o|__._| . |_ _ _| |_| | | |
| | | | | . | | . | . | | | . | . |__ |
|___|_|_|__/_|_|_|_|__/_|___|___|___|___|___|
#+end_example
**** Available Models
(a) another:latest (d) jamesio:latest
(b) funnyname2:latest (e) tinyllama:latest
(c) funnyname:latest (f) llama:latest
**** Quick Tips
- Ask me anything! C-c C-c
- Change model C-c m
- Cancel request C-c k
- Browse prompt history M-p/M-n
- Advanced interface (show all tips) C-c A

and of the more advanced version

*** Welcome to OLLAMA BUDDY
#+begin_example
___ _ _ n _ n ___ _ _ _ _
| | | |__._|o(Y)o|__._| . |_ _ _| |_| | | |
| | | | | . | | . | . | | | . | . |__ |
|___|_|_|__/_|_|_|_|__/_|___|___|___|___|___|
#+end_example
**** Available Models
(a) another:latest (d) jamesio:latest
(b) funnyname2:latest (e) tinyllama:latest
(c) funnyname:latest (f) llama:latest
**** Quick Tips
- Ask me anything! C-c C-c
- Show Help/Token-usage/System-prompt C-c h/U/C-s
- Model Change/Info/Cancel C-c m/i/k
- Prompt history M-p/M-n
- Session New/Load/Save/List/Delete C-c N/L/S/Y/W
- History Toggle/Clear/Show C-c H/X/V
- Prompt to multiple models C-c l
- Parameter Edit/Show/Help/Reset C-c P/G/I/K
- System Prompt/Clear C-u/+C-u +C-u C-c C-c
- Toggle JSON/Token/Params/Format C-c D/T/Z/C-o
- Basic interface (simpler display) C-c A
- In another buffer? M-x ollama-buddy-menu

<2025-03-17 Mon> 0.9.0

Added command-specific parameter customization

Added :parameters property to command definitions for granular control
Implemented functions to apply and restore parameter settings
Added example configuration to refactor-code command

With the latest update, you can now define specific parameter sets for each command in the menu, enabling you to optimize each AI interaction for its particular use case.

Different AI tasks benefit from different parameter settings. When refactoring code, you might want a more deterministic, precise response (lower temperature, higher repetition penalty), but when generating creative content, you might prefer more variation and randomness (higher temperature, lower repetition penalty). Previously, you had to manually adjust these parameters each time you switched between different types of tasks.

The new command-specific parameters feature lets you pre-configure the optimal settings for each use case. Here’s how it works:

Key Features

Per-Command Parameter Sets: Define custom parameter values for each command in your menu
Automatic Application: Parameters are applied when running a command and restored afterward
Non-Destructive: Your global parameter settings remain untouched
Easy Configuration: Simple interface for adding or updating parameters

Example Configuration

;; Define a command with specific parameters
(refactor-code
 :key ?r
 :description "Refactor code"
 :prompt "refactor the following code:"
 :system "You are an expert software engineer..."
 :parameters ((temperature . 0.2) (top_p . 0.7) (repeat_penalty . 1.3))
 :action (lambda () (ollama-buddy--send-with-command 'refactor-code)))

;; Add parameters to an existing command
(ollama-buddy-add-parameters-to-command 'git-commit
 :temperature 0.4
 :top_p 0.9
 :repeat_penalty 1.1)

;; Update properties and parameters at once
(ollama-buddy-update-command-with-params 'describe-code
 :model "codellama:latest"
 :parameters '((temperature . 0.3) (top_p . 0.8)))

This feature is particularly useful for:

Code-related tasks: Lower temperature for more deterministic code generation
Creative writing: Higher temperature for more varied and creative outputs
Technical explanations: Balanced settings for clear, accurate explanations
Summarization tasks: Custom parameters to control verbosity and focus

<2025-03-16 Sun> 0.8.5

Added system prompt support for commands

Introduced `:system` field to command definitions.
Added `ollama-buddy-show-system-prompt` to view active system prompt.
Updated UI elements to reflect system prompt status.

Previously, individual menu commands in ollama-buddy only included a user prompt. Now, each command can define a system prompt, which provides background context to guide the AI’s responses. This makes interactions more precise and tailored.

Key Features

System prompts per command: Specify background instructions for each AI-powered command using the new :system field.
View active system prompt: Use C-c C-s to display the current system prompt in a dedicated buffer.
Updated UI elements: The status line now indicates whether a system prompt is active.

A helper function has also been added to update the default menu, for example, you might want to tweak a couple of things:

(use-package ollama-buddy
 :bind ("C-c o" . ollama-buddy-menu)
 :custom
 (ollama-buddy-default-model "llama3.2:3b")
 :config
 (ollama-buddy-update-menu-entry
 'refactor-code
 :model "qwen2.5-coder:7b"
 :system "You are an expert software engineer who improves code and only mainly using the principles exhibited by Ada")
 (ollama-buddy-update-menu-entry
 'git-commit
 :model "qwen2.5-coder:3b"
 :system "You are a version control expert and mainly using subversion"))

Ollama-Buddy 0.8.0 - Added System Prompts, Model Info and simpler menu model assignment

James Dyer — Fri, 14 Mar 2025 13:21:00 +0000

More improvements to ollama-buddy https://github.com/captainflasmr/ollama-buddy

The main addition is that of system prompts, which allows setting the general tone and guidance of the overall chat. Currently the system prompt can be set at any time and turned on and off but I think to enhance my model/command for each menu item concept, I could also add a :system property to the menu alist definition to allow even tighter control of a menu action to prompt response.

Also now I have parameter functionality working for fine grained control, I could add these individual parameters for each menu command, for example the temperature could be very useful in this case to play around with the randomness/casualness of the response.

The next improvement will likely involve adding support for interacting more directly with Ollama to create and pull models. However, I’m still unsure whether performing this within Emacs is the best approach, I could assume that all models are already set up in Ollama.

That said, importing a GGUF file might be a useful feature, possibly from within dired. Currently, this process requires multiple steps: creating a simple model file that points to the GGUF file on disk, then running the ollama create command to import it. Streamlining this workflow could enhance usability.

Then maybe on to embeddings, of which I currently have no idea, haven’t read up on it, nuffin, but that is something to look forward to! :)

Anyways, here is the latest set of updates to Ollama Buddy:

<2025-03-14 Fri> 0.8.0

Added system prompt support

Added ollama-buddy--current-system-prompt variable to track system prompts
Updated prompt area rendering to distinguish system prompts
Modified request payload to include system prompt when set
Enhanced status bar to display system prompt indicator
Improved help menu with system prompt keybindings

So this is system prompt support in Ollama Buddy!, allowing you to set and manage system-level instructions for your AI interactions. This feature enables you to define a persistent system prompt that remains active across user queries, providing better control over conversation context.

Key Features

You can now designate any user prompt as a system prompt, ensuring that the AI considers it as a guiding instruction for future interactions. To set the system prompt, use:

C-u C-c C-c

Example:

Type:

Always respond in a formal tone.

Press C-u C-c C-c This prompt is now set as the system prompt and any further chat ollama responses will adhere to the overarching guidelines defined in the prompt.

If you need to clear the system prompt and revert to normal interactions, use:

C-u C-u C-c C-c

How It Works

The active system prompt is stored and sent with each user prompt.
A “S” indicator appears in the status bar when a system prompt is active.
The request payload now includes the system role, allowing AI to recognize persistent instructions.

Demo

Set the system message to:

You must always respond in a single sentence.

Now ask the following:

Tell me why Emacs is so great!

Tell me about black holes

clear the system message and ask again, the responses should now be more verbose!!

<2025-03-13 Thu> 0.7.4

Added model info command, update keybindings

Added `ollama-buddy-show-raw-model-info` to fetch and display raw JSON details of the current model in the chat buffer.
Updated keybindings:
- `C-c i` now triggers model info display.
- `C-c h` mapped to help assistant.
- Improved shortcut descriptions in quick tips section.
Removed unused help assistant entry from menu.
Changed minibuffer-prompt key from `?i` to `?b`.

<2025-03-12 Wed> 0.7.3

Added function to associate models with menu commands

Added ollama-buddy-add-model-to-menu-entry autoload function
Enabled dynamic modification of command-model associations

This is a helper function that allows you to associate specific models with individual menu commands.

Configuration to apply a model to a menu entry is now straightforward, in your Emacs init file, add something like:

(with-eval-after-load 'ollama-buddy
 (ollama-buddy-add-model-to-menu-entry 'dictionary-lookup "tinyllama:latest")
 (ollama-buddy-add-model-to-menu-entry 'synonym "tinyllama:latest"))

This configures simpler tasks like dictionary lookups and synonym searches to use the more efficient TinyLlama model, while your default model will still be used for more complex operations.

<2025-03-12 Wed> 0.7.2

Added menu model colours back in and removed some redundant code

Ollama-Buddy 0.7.1 - Org-mode Chat, Parameter Control and JSON Debugging

James Dyer — Tue, 11 Mar 2025 18:07:00 +0000

Continuing the development of my local ollama LLM client called ollama-buddy…

https://github.com/captainflasmr/ollama-buddy

The basic functionality, I think, is now there (and now literally zero configuration required). If a default model isn’t set I just pick the first one, so LLM chat can take place immediately.

Now I’m getting more into this chat client malarkey, my original idea of a very minimal chat client to interface to ollama is starting to skew into supporting as much of the ollama RESTful API as possible. Hence in this update a more advanced approach is creeping in, including setting up various subtle model parameters and providing a debugging window to monitor incoming raw JSON (pretty printed of course). Hopefully, these features will remain tucked away for advanced users, I’ve done my best to keep them unobtrusive (but not too hidden). The tool is still designed to be a helpful companion to interface to ollama through Emacs, just now with more powerful options under the hood.

Also a note about converting the chat buffer into org-mode. My original intention was to keep the chat buffer as a very simple almost “no mode” buffer, with just text and nothing else. However, with more consideration, I felt that converting this buffer into org-mode actually held quite a few benefits:

Each prompt could be a heading, hence outlining and folding can be activated!
Navigation between prompts now comes for free (especially if you are using org-use-speed-commands)
The org ox export backend now allows us to export to formats of many different kinds

I’m sure there are more as this list isn’t quite the “quite a few benefits” I was hoping for :(

I have a local keymap defined with some ollama-buddy specific keybindings, and as of yet I haven’t encountered any conflicts with commonly used org-mode bindings but we shall see how it goes. I think for this package it is important to have a quick chatting mechanism, and what is faster than a good keybind?

Finally, just a note on the pain of implementing a good prompt mechanism. I had a few goes at it and I think I now have an acceptable robust solution. I kept running into little annoying edge cases and I ended up having to refactor quite a bit. My original idea for this package involved a simple “mark region and send” as at the time I had a feeling that the implementation of a good prompt mechanism would be tough - how right I was!. Things got even trickier with the move to org-mode, since each prompt heading should contain meaningful content for clean exports and I had to implement a mechanism to replace prompts intelligently. For example, if the model is swapped and the previous prompt is blank, it gets replaced, though, of course, even this has its own edge cases - gives a new meaning to prompt engineering! :)

Anyways, listed below are my latest changes, with a little deeper dive into more “interesting” implementations, my next ideas are a little more advanced and are kanban’d into my github README at https://github.com/captainflasmr/ollama-buddy for those that are interested.

<2025-03-11 Tue> 0.7.1

Added debug mode to display raw JSON messages in a debug buffer

Created new debug buffer to show raw JSON messages from Ollama API
Added toggle function to enable/disable debug mode (ollama-buddy-toggle-debug-mode)
Modified stream filter to log and pretty-print incoming JSON messages
Added keybinding C-c D to toggle debug mode
Updated documentation in welcome message

<2025-03-11 Tue> 0.7.0

Added comprehensive Ollama parameter management

Added customization for all Ollama option API parameters with defaults
Only send modified parameters to preserve Ollama defaults
Display active parameters with visual indicators for modified values
Add keybindings and help system for parameter management
Remove redundant temperature controls in favor of unified parameters

Introduced parameter management capabilities that give you complete control over your Ollama model’s behavior through the options in the ollamas API.

Ollama’s API supports a rich set of parameters for fine-tuning text generation, from controlling creativity with temperature to managing token selection with top_p and top_k. Until now, Ollama Buddy only exposed the temperature parameter, but this update unlocks the full potential of Ollama’s parameter system!

Key Features:

All Parameters - set all custom options for the ollama LLM at runtime
Smart Parameter Management: Only modified parameters are sent to Ollama, preserving the model’s built-in defaults for optimal performance
Visual Parameter Interface: Clear display showing which parameters are active with highlighting for modified values

Keyboard Shortcuts

Parameter management is accessible through simple keyboard shortcuts from the chat buffer:

C-c P - Edit a parameter
C-c G - Display current parameters
C-c I - Show parameter help
C-c K - Reset parameters to defaults

<2025-03-10 Mon> 0.6.1

Refactored prompt handling so each org header line should now always have a prompt for better export

Added functionality to properly handle prompt text when showing/replacing prompts
Extracted inline lambdas in menu actions into named functions
Added fallback for when no default model is set

<2025-03-08 Sat> 0.6.0

Chat buffer now in org-mode

Enabled org-mode in chat buffer for better text structure
Implemented ollama-buddy--md-to-org-convert-region for Markdown to Org conversion
Turn org conversion on and off
Updated keybindings C-c C-o to toggle Markdown to Org conversion

Key Features

The chat buffer is now in org-mode which gives the buffer enhanced readability and structure. Now, conversations automatically format user prompts and AI responses with org-mode headings, making them easier to navigate.
Of course with org-mode you will now get the additional benefits for free, such as:
- outlining
- org export
- heading navigation
- source code fontification
Previously, responses in Ollama Buddy were displayed in markdown formatting, which wasn’t always ideal for org-mode users. Now, you can automatically convert Markdown elements, such as bold/italic text, code blocks, and lists, into proper org-mode formatting. This gives you the flexibility to work with markdown or org-mode as needed.

Ollama-Buddy V0.5.1 - Session/History/Role Management, Real-Time Token Tracking and More!

James Dyer — Fri, 07 Mar 2025 13:50:00 +0000

I’ve been a busy little bee in the last few days, so quite a few improvements to ollama-buddy, my Emacs LLM ollama client, they are listed below:

<2025-03-07 Fri> 0.5.1

Added temperature control

Implemented temperature control parameter
Added menu commands for setting (T), resetting (0)
Added keybindings (C-c t/T/0) for quick temperature adjustments
Updated header line and prompt displays to show current temperature
Included temperature info in welcome screen with usage guidance

This addition gives users fine-grained control over the creativity and randomness of their AI responses through a new temperature variable.

This update adds several convenient ways to control temperature in Ollama-Buddy:

Key Features

Direct Temperature Setting: Use C-c t from the chat buffer or the menu command [T] to set an exact temperature value between 0.0 and 2.0.
Preset Temperatures: Quickly switch between common temperature presets with C-c T from the chat buffer:
- Precise (0.1) - For factual responses
- Focused (0.3) - For deterministic, coherent outputs
- Balanced (0.7) - Default setting
- Creative (0.9) - For more varied, creative responses
Reset to Default: Return to the default temperature (0.7) with C-c 0 or the menu command [0].
Visual Feedback: The current temperature is displayed in the header line and before each response, so you always know what setting you’re using.

<2025-03-06 Thu> 0.5.0

Implemented session management, so you can now save your conversations and bring them back with the relevant context and chat history!

Chat history is now maintained separately for each model
Added session new/load/save/delete/list functionality
A switch in context can now be achieved by any of the following methods:
- Loading a previous session
- Creating a new session
- Clearing history on the current session
- Toggling history on and off

Key Benefits

More relevant responses when switching between models
Prevents context contamination across different models
Clearer session management and organization

Key Features

Session Management

With session management, you can now:

Save session with ollama-buddy-sessions-save (or through the ollama-buddy-menu) Preserve your current conversation with a custom name
Load session with ollama-buddy-sessions-load (or through the ollama-buddy-menu) Return to previous conversations exactly where you left off
List all sessions with ollama-buddy-sessions-list (or through the ollama-buddy-menu) View all saved sessions with metadata including timestamps and models used
Delete session with ollama-buddy-sessions-delete (or through the ollama-buddy-menu) Clean up sessions you no longer need
New session with ollama-buddy-sessions-new (or through the ollama-buddy-menu) Begin a clean slate without losing your saved sessions
Menu Commands

The following commands have been added to the ollama-buddy-menu:

E New session
L Load session
S Save session
Y List sessions
K Delete session

<2025-03-04 Tue> 0.4.1

Added a sparse version of ollama-buddy called ollama-buddy-mini, see the github repository for the elisp file and a description in README-mini.org

<2025-03-03 Mon> 0.4.0

Added conversation history support and navigation functions

Implemented conversation history tracking between prompts and responses
Added configurable history length limits and visual indicators
Created navigation functions to move between prompts/responses in buffer

Key Features

Conversation History

Ollama Buddy now maintains context between your interactions by:

Tracking conversation history between prompts and responses
Sending previous messages to Ollama for improved contextual responses
Displaying a history counter in the status line showing conversation length
Providing configurable history length limits to control memory usage

You can control this feature with:

;; Enable/disable conversation history (default: t)
(setq ollama-buddy-history-enabled t)

;; Set maximum conversation pairs to remember (default: 10)
(setq ollama-buddy-max-history-length 10)

;; Show/hide the history counter in the header line (default: t)
(setq ollama-buddy-show-history-indicator t)

Enhanced Navigation

Moving through longer conversations is now much easier with:

Navigation functions to jump between prompts using C-c n/p
Menu Commands

Three new menu commands have been added:

H: Toggle history tracking on/off
X: Clear the current conversation history
V: View the full conversation history in a dedicated buffer

<2025-03-02 Sun> 0.3.1

Enhanced model colour contrast with themes, allowing ollama-buddy-enable-model-colors to be enabled by default.

<2025-03-01 Sat> 0.3.0

Added real-time token usage tracking and display

Introduce variables to track token counts, rates, and usage history
Implement real-time token rate updates with a timer
Add a function to display token usage statistics in a dedicated buffer
Allow toggling of token stats display after responses
Integrate token tracking into response processing and status updates
Ensure cleanup of timers and tracking variables on completion or cancellation

Key Features

Menu Commands

The following command has been added to the ollama-buddy-menu:
- t Show a summary of token model usage stats

<2025-02-28 Fri> 0.2.4

Added model-specific color highlighting

Introduce `ollama-buddy-enable-model-colors` (default: nil) to toggle model-based color highlighting.
Assign consistent colors to models based on string hashing.
Apply colors to model names in the menu, status, headers, and responses.
Add `ollama-buddy-toggle-model-colors` command to toggle this feature.

This enhancement aims to improve user experience by visually distinguishing different AI models within the interface.

Note: I am likely to use both colour and color interchangeably in the following text! :)

Key Features

Model-Specific Colors
- A new customizable variable, ollama-buddy-enable-model-colors, allows users to enable or disable model-specific colors.
- Colors are generated based on a model’s name using a hashing function that produces consistent and visually distinguishable hues.
- However there could be an improvement regarding ensuring the contrast is sufficient and hence visibility maintained with differing themes.
Interactive Color Toggle
- Users can toggle model-specific colors with the command ollama-buddy-toggle-model-colors, providing flexibility in interface customization.
Colored Model Listings
- Model names are now displayed with their respective colors in various parts of the interface, including:
  - The status line
  - Model selection menus
  - Command definitions
  - Chat history headers
Menu Commands

The following command hashing been added to the ollama-buddy-menu:

C Toggle colors

<2025-02-28 Fri> 0.2.3

Added Prompt History Support

Prompts are now integrated into the Emacs history mechanism which means they persist across sessions.
Use M-p to navigate prompt history, and M-p / M-n within the minibuffer to insert previous prompts.

Key Features

Persistent prompt history
A new variable, ollama-buddy--prompt-history, now keeps track of past prompts. This means you can quickly recall and reuse previous queries instead of retyping them from scratch.
M-p - recall a previous prompt in the buffer which will bring up the minibuffer for prompt history selection.
Minibuffer M-p / M-n - Navigate through past prompts when prompted for input.

<2025-02-27 Thu> 0.2.2

Added support for role-based presets

Introduced `ollama-buddy-roles-directory` for storing role preset files.
Implemented interactive functions to manage roles:
- `ollama-buddy-roles-switch-role`
- `ollama-buddy-role-creator-create-new-role`
- `ollama-buddy-roles-open-directory`
Added ability to create and switch between role-specific commands.
Updated menu commands to include role management options.

This enhancement allows you to create, switch, and manage role-specific command configurations, which basically generates differing menu layouts and hence command options based on your context, making your workflow more personalized and efficient.

What Are Role-Based Presets?

Roles in Ollama Buddy are essentially profiles tailored to specific tasks. Imagine you’re using Ollama Buddy for:

Coding assistance with one set of prompts
Creative writing with a different tone and response style
Generating Buffy Style Quips - just a fun one!

With this update, you can now create presets for each of these contexts and switch between them seamlessly without manually re-configuring settings every time. On each switch of context and hence role, a new ollama buddy menu will be generated with the associated keybinding attached to the relevant context commands.

Key Features

1. Store Your Custom Roles

A new directory ollama-buddy-roles-directory (defaulting to ~/.emacs.d/ollama-buddy-presets/) now holds your role presets. Each role is saved as an .el file containing predefined commands, shortcuts, and model preferences.

2. Easily Switch Between Roles

With M-x ollama-buddy-roles-switch-role you can pick from available role presets and swap effortlessly between them (or use the menu item from ollama-buddy-menu)

3. Create Custom Roles with Unique Commands

You can now define custom commands for each role with M-x ollama-buddy-role-creator-create-new-role (or the menu item from ollama-buddy-menu)

This interactive function allows you to:

Assign menu shortcuts to commands
Describe command behaviour
Set a default AI model
Define a system prompt for guiding responses

Once saved, your new role is ready to load anytime!

4. Open Role Directory in Dired

Need to tweak a role manually? A simple, run M-x ollama-buddy-roles-open-directory or of course also from the ollama-buddy-menu which opens the presets folder in dired, where you can quickly edit, copy, or delete role configurations.

5. Preconfigured presets are available if you’d like to use a ready-made setup.

ollama-buddy–preset__buffy.el
ollama-buddy–preset__default.el
ollama-buddy–preset__developer.el
ollama-buddy–preset__janeway.el
ollama-buddy–preset__translator.el
ollama-buddy–preset__writer.el

If these files are put in the ollama-buddy-roles-directory then the role selection menu will pass through completing-read, and present the following:

{buffy | default | developer | janeway | translator | writer}

With the selection regenerating the ollama-buddy-menu accordingly, and off you go.

6. Menu commands

The following commands have been added to the ollama-buddy-menu:

R Switch Role
N Create New Role
D Open Roles Directory

Ollama Buddy Version 0.2.1 - Same prompt to multiple LLMs and choose best answer!

James Dyer — Sun, 02 Mar 2025 09:35:00 +0000

Some improvements to my ollama LLM package…

With the new multishot mode, you can now send a prompt to multiple models in sequence, and compare their responses, the results are also available in named registers.

Letter-Based Model Shortcuts

Instead of manually selecting models, each available model is now assigned a letter (e.g., (a) mistral, (b) gemini). This allows for quick model selection when sending prompts or initiating a multishot sequence.

Multishot Execution (C-c C-l)

Ever wondered how different models would answer the same question? With Multishot Mode, you can:

Send your prompt to a sequence of models in one shot.
Track progress as responses come in.
Store each model’s response in a register, making it easy to reference later, each assigned model letter corresponds to the named register.

Status Updates

When running a multishot execution, the status now updates dynamically:

“Multi Start” when the sequence begins.
“Processing…” during responses.
“Multi Finished” when all models have responded.

How It Works

C-c C-l to start a multishot session in the chat buffer.
Type a sequence of model letters (e.g., abc to use models mistral, gemini, and llama).
The selected models will process the prompt one by one.
The responses will be saved to registers of the same named letter for recalling later.

Installing Emacs 30.1 On Arch and SUSE

James Dyer — Wed, 26 Feb 2025 14:05:00 +0000

Seems to be a common post at the moment, so I thought I would quickly put out there how I updated to Emacs 30.1.

I use an Arch spin called Garuda, running SwayWM, so as its on wayland, this for me is simple, just update the system using pacman -Syu and emacs-wayland will pull in 30.1 automatically!

For my other environments, or if I want to build old versions of Emacs from source, I use the following script:

#!/bin/bash

# Directory for Emacs builds
BUILD_ROOT="$HOME/emacs-builds"
INSTALL_ROOT="$HOME/emacs-versions"

# Build dependencies for different distributions
ARCH_BUILD_DEPS="base-devel gtk2 gtk3 libxpm libjpeg-turbo libpng libtiff giflib libxml2 gnutls librsvg"
SLES_BUILD_DEPS="gcc gcc-c++ make automake gtk2-devel gtk3-devel libXpm-devel libjpeg8-devel libpng16-devel libtiff-devel giflib-devel libxml2-devel gnutls-devel cairo-devel harfbuzz-devel librsvg-devel"

# 27.2 2021-03-25
# 28.2 2022-09-12
# 29.4 2024-06-22
VERSIONS=(
 "emacs-27.2"
 "emacs-28.2"
 "emacs-29.4"
 "emacs-30.1"
)

# Detect OS
detect_os() {
 if [ -f /etc/os-release ]; then
 . /etc/os-release
 OS=$NAME
 else
 OS=$(uname -s)
 fi
}

function prepare_environment() {
 echo "Creating build directories..."
 mkdir -p "$BUILD_ROOT"
 mkdir -p "$INSTALL_ROOT"

 detect_os
 echo "Detected OS: $OS"

 case "$OS" in
 *"SLED"*|"SLES"*|*"SUSE"*)
 echo "Installing build dependencies for SUSE SLES..."
 sudo zypper refresh
 sudo zypper install -y pattern-devel-base-devel
 sudo zypper install -y $SLES_BUILD_DEPS
 ;;
 *"Garuda"*)
 echo "Installing build dependencies for Arch Linux..."
 sudo pacman -Syu --needed --noconfirm $ARCH_BUILD_DEPS

 # Check if we have yay for AUR access (optional)
 if ! command -v yay &> /dev/null; then
 echo "Installing yay (AUR helper)..."
 cd /tmp
 git clone https://aur.archlinux.org/yay.git
 cd yay
 makepkg -si --noconfirm
 fi
 ;;
 *)
 echo "Unsupported OS detected: $OS"
 echo "Please install build dependencies manually and continue."
 read -p "Press Enter to continue or Ctrl+C to abort..."
 ;;
 esac
}

function build_emacs() {
 local version=$1
 local build_dir="$BUILD_ROOT/$version"
 local install_dir="$INSTALL_ROOT/$version"

 echo "Building $version..."

 # Download and extract
 cd "$BUILD_ROOT"
 if [ ! -f "$version.tar.gz" ]; then
 wget "https://ftp.gnu.org/gnu/emacs/$version.tar.gz"
 fi

 # Clean previous build if exists
 rm -rf "$build_dir"
 tar xzf "$version.tar.gz"

 # Configure and build
 cd "$version"

 # Different configure flags for different versions
 if [[ "$version" == "emacs-24.5" || "$version" == "emacs-25.3" ]]; then
 # Older versions use GTK2
 ./configure \
 --prefix="$install_dir" \
 --with-x-toolkit=gtk2 \
 --with-xpm \
 --with-jpeg \
 --with-png \
 --with-gif \
 --with-tiff \
 --with-gnutls \
 --with-xml2 \
 --with-rsvg
 else
 # Newer versions use GTK3
 ./configure \
 --prefix="$install_dir" \
 --with-x-toolkit=gtk3 \
 --with-xpm \
 --with-jpeg \
 --with-png \
 --with-gif \
 --with-tiff \
 --with-gnutls \
 --with-xml2 \
 --with-cairo \
 --with-harfbuzz \
 --with-rsvg
 fi

 # Use all available cores for compilation
 make -j$(nproc)
 make install

 echo "$version installed to $install_dir"
}

function create_pkgbuild() {
 # Only create PKGBUILD for Arch Linux
 if [[ "$OS" != *"Arch Linux"* ]]; then
 echo "PKGBUILD creation is only supported on Arch Linux"
 return 1
 fi

 local version=$1
 local version_num=${version#emacs-}

 echo "Creating PKGBUILD for $version..."
 mkdir -p "$BUILD_ROOT/pkgbuilds/$version"
 cd "$BUILD_ROOT/pkgbuilds/$version"

 cat > PKGBUILD << EOF
# Maintainer: Your Name <your.email@example.com>
pkgname=$version
pkgver=$version_num
pkgrel=1
pkgdesc="GNU Emacs version $version_num"
arch=('x86_64')
url="https://www.gnu.org/software/emacs/"
license=('GPL3')
depends=('gtk3' 'libxpm' 'libjpeg-turbo' 'libpng' 'giflib' 'libtiff' 'libxml2' 'gnutls')
makedepends=('base-devel')
provides=("emacs-$version_num")
conflicts=("emacs")
source=("https://ftp.gnu.org/gnu/emacs/emacs-\$pkgver.tar.gz")
sha256sums=('SKIP')

build() {
 cd "\$srcdir/emacs-\$pkgver"
 ./configure \\
 --prefix=/usr \\
 --sysconfdir=/etc \\
 --libexecdir=/usr/lib \\
 --localstatedir=/var \\
 --with-x-toolkit=gtk3 \\
 --with-xpm \\
 --with-jpeg \\
 --with-png \\
 --with-gif \\
 --with-tiff \\
 --with-gnutls \\
 --with-xml2
 make
}

package() {
 cd "\$srcdir/emacs-\$pkgver"
 make DESTDIR="\$pkgdir" install
}
EOF
}

# Main execution
echo "This script provides two methods to build Emacs:"
echo "1. Direct compilation (traditional)"
echo "2. Using makepkg (Arch Linux only)"
read -p "Which method do you prefer? (1/2): " build_method

case $build_method in
 1)
 prepare_environment
 for version in "${VERSIONS[@]}"; do
 build_emacs "$version"
 done

 # Create convenience symlinks
 mkdir -p "$HOME/bin"
 echo "Creating version-specific symlinks..."
 for version in "${VERSIONS[@]}"; do
 ln -sf "$INSTALL_ROOT/$version/bin/emacs" "$HOME/bin/emacs-${version#emacs-}"
 done
 ;;

 2)
 detect_os
 if [[ "$OS" != *"Arch Linux"* ]]; then
 echo "makepkg method is only supported on Arch Linux"
 exit 1
 fi
 prepare_environment
 for version in "${VERSIONS[@]}"; do
 create_pkgbuild "$version"
 echo "PKGBUILD created for $version"
 echo "To build, cd to $BUILD_ROOT/pkgbuilds/$version and run 'makepkg -si'"
 done
 ;;

 *)
 echo "Invalid option selected"
 exit 1
 ;;
esac

echo "Build complete. You can run specific versions using:"
for version in "${VERSIONS[@]}"; do
 echo "emacs-${version#emacs-}"
done

Ollama Buddy - Now On MELPA!

James Dyer — Mon, 24 Feb 2025 15:42:00 +0000

 ___ _ _ n _ n ___ _ _ _ _
| | | |__._|o(Y)o|__._| . |_ _ _| |_| | | |
| | | | | . | | . | . | | | . | . |__ |
|___|_|_|__/_|_|_|_|__/_|___|___|___|___|___|

https://github.com/captainflasmr/ollama-buddy

A friendly Emacs interface for interacting with Ollama models. This package provides a convenient way to integrate Ollama’s local LLM capabilities directly into your Emacs workflow with little or no configuration required.

Latest improvements:

Chat buffer now more prompt based rather than ad-hoc using C-c C-c to send and C-c C-k to cancel
Connection monitor now optional, ollama status visibility now maintained by strategic status checks simplifying setup.
Can now change models from chat buffer using C-c C-m
Updated intro message with ascii logo
Suggested default “C-c o” for ollama-buddy-menu
defcustom ollama-buddy-command-definitions now will work in the customization interface.
The presets directory on github contains elisp files that can be evaluated to generate a role-based menu.
Added to MELPA, install using the following:

(use-package ollama-buddy
 :bind ("C-c o" . ollama-buddy-menu))

and to add initial model:

(use-package ollama-buddy
 :bind ("C-c o" . ollama-buddy-menu)
 :custom ollama-buddy-default-model "llama3.2:1b")

Roadmap :

DOING Multi-shot prompt to multiple LLMS to choose best answer
DOING Customizable Role-Based Menu Preset Generation System
DOING Distinguishing commands associated with LLMs using colours

For any more information just have a look at the github README!

Why I Switched from Magit to VC-Mode (and How It Works for Me)

James Dyer — Fri, 21 Feb 2025 07:54:00 +0000

I am currently using vc-mode for my source code configuration needs. I wouldn’t call myself a die-hard vc-mode user, (at least not yet!). To earn that title, I think I would need years of experience with it and scoffing at this newfangled thing they call magit, while my muscle memory recoils at the thought of reading and interacting with a transient menu!

If that were the case, I’d fully embrace the label of a die-hard holdout. But in reality, that just isn’t true.

My version control history has been, well, complicated, or to put it another way, quite simple. It largely revolves around that ancient system known as Subversion (svn), and leveraging it through the good old command line. It wasn’t until the past couple of years that I even stepped into the Emacs version control ecosystem. So where to start? Naturally, I had heard a lot of praise for magit.

First question (and I suspect the usual question): how do you even pronounce it? A soft “g” like in magic? That sounds better, even if it doesn’t make much sense. Then again, given that I’d likely never discuss it with colleagues at work, pronunciation hardly matters.

Anyway, I happily “magited” for a year or so (ironically, I think I learned more about Git’s command line through magit than I would have otherwise). I would have continued using it too, except I decided to make a mental paradigm shift regarding my use in Emacs in general.

I had reached a point where I think I knew enough Emacs Lisp to start replacing many external packages with custom functions. It was a personal challenge, an opportunity to deepen my understanding of elisp and tackle more advanced customization. What better way to learn than by replacing something like ace-window? As it turns out, most of these substitutions were fairly straightforward.

But magit? Now that was a tough one. Should I create my own transient menu?, or a more basic menu system? It’s Git, so that could quickly become a tangled mess of options. At the same time, I couldn’t ignore my need for Subversion support at work. magit, as great as it is, is Git-only (though git svn exists).

Wouldn’t it be nice if there was a version control system that seamlessly handled multiple backends?

Turns out (as we already know), Emacs has one built-in and that is vc-mode.

I’ve now been using vc-mode for about a year. I still appreciate magit, but for my current workflow, balancing Git for personal projects and Subversion at work, vc-mode gets the job done.

I’m not generally using Git in any advanced fashion anyway and if I do need to drop into the command line then I can just open up a terminal in emacs.

Yes vc-mode has its limitations, for example, why is creating a tag not part of the default keymap of vc-dir?, actually I think it is and I vaguely remember activating it through vc-create-branch, was it a universal argument?, I can’t remember, but how about just doing things the old-fashioned way, M-x vc-create-tag?, that works fine for me. Maybe in the not too near future I can yak shave that away anyway! :)

So far with vc-mode I’ve made some small improvements, which I shall share in future blog posts:

Adding the ability to toggle tracked files on and off.
Displaying the current branch permanently in the vc-dir header line.

And actually the vc-mode tweaks above were the original topic of this post, but I seem to have rambled on long enough…

Ollama Buddy - Local LLM Integration for Emacs

James Dyer — Fri, 07 Feb 2025 09:40:00 +0000

I have been playing around with local LLMs recently through ollama and decided to create the basis for an Emacs package to focus on interfacing to ollama specifically. My idea here is to implement something very minimal and as light-weight as possible and that could be run out-of-the-ollamabox with no configuration (obviously the ollama server just needs to be running). I have a deeper dive into my overall design thoughts and decisions in the github README and there are some simple demos:“hello”

https://github.com/captainflasmr/ollama-buddy

Overview

The name is just something a little bit fun and it seems to always remind me of the “bathroom buddy” from the film Gremlins (although hopefully this will work better than that seemed to!)

Screenshots / Demos

Note that all the demos are in real time.

Switching to a better model

More conversational

Describing code with different models

Describing code with a more advanced model

The Menu

Summary of my design ethos

Focused Design Philosophy
- Dedicated solely to Ollama integration (unlike general-purpose LLM packages)
- Intentionally lightweight and minimal setup
- Particularly suitable for air-gapped systems
- Avoids complex backends and payload configurations
Interface Design Choices
- Flexible, customizable menu through defcustom
- Easy-to-extend command system via simple alist modifications
- Region-based interaction model across all buffers
Buffer Implementation
- Simple, editable chat buffer approach
- Avoids complex modes or bespoke functionality
- Trying to leverage standard Emacs text editing capabilities
User Experience
- “AI assistant” style welcome interface
- Zero-config startup possible
- Built-in status monitoring and model listing
- Simple tutorial-style introduction
Technical Simplicity
- REST-based Ollama
- Quickly switch between small local LLMs
- Backwards compatibility with older Emacs versions
- Minimal dependencies
- Straightforward configuration options

Design ethos expanded / why create this package?

The Ollama Emacs package ecosystem is still emerging. Although there are some great implementations available, they tend to be LLM jack-of-all-trades, catering to various types of LLM integrations, including, of course, the major online offerings.

Recently, I have been experimenting with a local solution using ollama. While using ollama through the terminal interface with readline naturally leans toward Emacs keybindings, there are a few limitations:

Copy and paste do not use Emacs keybindings like readline navigation. This is due to the way key codes work in terminals, meaning that copying and pasting into Emacs would require using the mouse!
Searching through a terminal with something like Emacs isearch can vary depending on the terminal.
Workflow disruption occur when copying and pasting between Emacs and ollama.
There is no easy way to save a session.
It is not using Emacs!

I guess you can see where this is going. The question is: how do I integrate a basic query-response mechanism to ollama into Emacs? This is where existing LLM Emacs packages come in, however, I have always found them to be more geared towards online models with some packages offering experimental implementations of ollama integration. In my case, I often work on an air-gapped system where downloading or transferring packages is not straightforward. In such an environment, my only option for LLM interaction is ollama anyway. Given the limitations mentioned earlier of interacting with ollama through a terminal, why not create a dedicated ollama Emacs package that is very simple to set up, very lightweight and leverages Emacs’s editing capabilities to provide a basic query response interface to ollama?

I have found that setting up ollama within the current crop of LLM Emacs packages can be quite involved. I often struggle with the setup, I get there in the end, but it feels like there’s always a long list of payloads, backends, etc., to configure. But what if I just want to integrate Emacs with ollama? It has a RESTful interface, so could I create a package with minimal setup, allowing users to define a default model in their init file (or select one each time if they prefer)? It could also query the current set of loaded models through the ollama interface and provide a completing-read type of model selection, with potentially no model configuration needed!

Beyond just being lightweight and easy to configure, I also have another idea: a flexible menu system. For a while, I have been using a simple menu-based interface inspired by transient menus. However, I have chosen not to use transient because I want this package to be compatible with older Emacs versions. Additionally, I haven’t found a compelling use case for a complex transient menu and I prefer a simple, opaque top level menu.

To achieve this, I have decided to create a flexible defcustom menu system. Initially, it will be configured for some common actions, but users can easily modify it through the Emacs customization interface by updating a simple alist.

For example, to refactor code through an LLM, a prepended text string of something like “Refactor the following code:” is usually applied. To proofread text, “Proofread the following:” could be prepended to the body of the query. So, why not create a flexible menu where users can easily add their own commands? For instance, if someone wanted a command to uppercase some text (even though Emacs can already do this), they could simply add the following entry to the ollama-buddy-menu-items alist:

(?u . ("Upcase"
 (lambda () (ollama-buddy--send "convert the following to uppercase:"))))

Then the menu would present a menu item “Upcase” with a “u” selection, upcasing the selected region. You could go nuts with this, and in order to double down on the autogeneration of a menu concept, I have provided a defcustom ollama-buddy-menu-columns variable so you can flatten out your auto-generated menu as much as you like!

This is getting rambly, but another key design consideration is how prompts should be handled and in fact how do I go about sending text from within Emacs?. Many implementations rely on a chat buffer as the single focal point, which seems natural to me, so I will follow a similar approach.

I’ve seen different ways of defining a prompt submission mechanism, some using <RET>, others using a dedicated keybinding like C-c <RET>, so, how should I define my prompting mechanism? I have a feeling this could get complicated, so lets use the KISS principle, also, how should text be sent from within Emacs buffers? My solution? simply mark the text and send it, not just from any Emacs buffer, but also within the chat window. It may seem slightly awkward at first (especially in the chat buffer, where you will have to create your prompt and then mark it), but it provides a clear delineation of text and ensures a consistent interface across Emacs. For example, using M-h to mark an element requires minimal effort and greatly simplifies the package implementation. This approach also allows users to use the scratch buffer for sending requests if so desired!

Many current implementations create a chat buffer with modes for local keybindings and other features. I have decided not to do this and instead, I will provide a simple editable buffer (ASCII text only) where all ollama interactions will reside. Users will be able to do anything in that buffer; there will be no bespoke Ollama/LLM functionality involved. It will simply be based on a special buffer and to save a session?, just use save-buffer to write it to a file, Emacs to the rescue again!

Regarding the minimal setup philosophy of this package, I also want to include a fun AI assistant-style experience. Nothing complicated, just a bit of logic to display welcome text, show the current ollama status, and list available models. The idea is that users should be able to jump in immediately. If they know how to install/start ollama, they can install the package without any configuration, run `M-x ollama-buddy-menu`, and open the chat. At that point, the “AI assistant” will display the current ollama status and provide a simple tutorial to help them get started.

The backend?, well I decided simply to use curl to stimulate the ollama RESTful API, so you will need curl to be installed.

I have other thoughts regarding the use of local LLMs versus online AI behemoths. The more I use ollama with Emacs through this package, the more I realize the potential of smaller, local LLMs. This package allows for quick switching between these models while maintaining a decent level of performance on a regular home computer. I could, for instance, load up qwen-coder for code-related queries (I have found the 7B Q4/5 versions to work particularly well) and switch to a more general model for other queries, such as llama or even deepseek-r1.

Phew! That turned into quite a ramble, maybe I should run this text through ollama-buddy for proofreading! :)

AI assistant

A simple text information screen will be presented on the first opening of the chat, or when requested through the menu system:

==================== n_____n ====================
==================== | o Y o | ====================

 ╭──────────────────────────────────────╮
 │ Welcome to │
 │ OLLAMA BUDDY │
 │ Your Friendly AI Assistant │
 ╰──────────────────────────────────────╯

 Hi there!

 ollama RUNNING

 I'm here to help you with:

 - Code refactoring and analysis
 - Writing clear commit messages
 - Proofreading and text improvements
 - And much more!

 Quick Start/Tips:

 - Try typing a prompt in this buffer
 - Select/mark all prompt text (select region)
 - M-x ollama-buddy-menu
 - Select menu item
 - Now wait for ollama to do its magic!
 - You can switch models anytime with [m]
 - Use [x] to cancel a running request
 - You can send to this chat from any buffer

-------------------- | @ Y @ | --------------------

Features

Interactive menu-driven interface
Dedicated chat buffer with streaming responses
Easy model switching
Quick actions for common tasks:
- Code refactoring
- Git commit message generation
- Code description
- Text proofreading
- Text summarization
Cute ASCII art separators for chat messages
Region-based interaction with any buffer

Whats New

<2025-02-07 Fri>

Added query finished message.

<2025-02-06 Thu>

Initial release
Basic chat functionality
Menu-driven interface
Region-based interactions
Model switching support

Prerequisites

Ollama installed and running locally
Emacs 27.1 or later
curl command-line tool

Installation

Manual Installation

Clone this repository:

git clone https://github.com/captainflasmr/ollama-buddy.git

Add to your init.el:

(add-to-list 'load-path "path/to/ollama-buddy")
(require 'ollama-buddy)

MELPA (Coming Soon)

(use-package ollama-buddy
 :ensure t
 :bind ("C-c l" . ollama-buddy-menu))

Usage

Start your Ollama server locally
Use M-x ollama-buddy-menu or the default keybinding C-c l to open the menu
Select your preferred model using the [m] option
Select text in any buffer
Choose an action from the menu:

Key	Action	Description
o	Open chat buffer	Opens the main chat interface
m	Swap model	Switch between available Ollama models
h	Help assistant	Display help message
l	Send region	Send selected text directly to model
r	Refactor code	Get code refactoring suggestions
g	Git commit message	Generate commit message for changes
d	Describe code	Get code explanation
p	Proofread text	Check text for improvements
z	Make concise	Reduce wordiness while preserving meaning
c	Custom Prompt	Enter bespoke prompt through the minibuffer
x	Kill request	Cancel current Ollama request
q	Quit	Exit the menu

Key Bindings

Key	Description
`C-c l`	Open ollama-buddy menu

Customization

Custom variable	Description
ollama-buddy-awesome-categorize-prompts	Whether to categorize prompts based on common keywords.
ollama-buddy-awesome-prompts-file	Filename containing the prompts within the repository.
ollama-buddy-grok-api-endpoint	Endpoint for Grok chat completions API.
ollama-buddy-remote-models	List of available remote models.
ollama-buddy-command-definitions	Comprehensive command definitions for Ollama Buddy.
ollama-buddy-codestral-default-model	Default Mistral Codestral model to use.
ollama-buddy-interface-level	Level of interface complexity to display.
ollama-buddy-show-params-in-header	Whether to show modified parameters in the header line.
ollama-buddy-user-prompts-default-categories	List of default categories for user system prompts.
ollama-buddy-debug-mode	When non-nil, show raw JSON messages in a debug buffer.
ollama-buddy-rag-qdrant-url	URL for Qdrant server.
ollama-buddy-codestral-api-key	API key for accessing Mistral Codestral services.
ollama-buddy-mode	Non-nil if Ollama-Buddy mode is enabled.
ollama-buddy-grok-marker-prefix	Prefix used to identify Grok models in the ollama-buddy interface.
ollama-buddy-reasoning-markers	List of marker pairs that encapsulate reasoning/thinking sections.
ollama-buddy-awesome-update-on-startup	Whether to automatically update prompts when Emacs starts.
ollama-buddy-context-bar-width	Width of the context progress bar in characters.
ollama-buddy-sessions-directory	Directory containing ollama-buddy session files.
ollama-buddy-history-model-view-mode-map	Keymap for model-specific history viewing mode.
ollama-buddy-rag-provider-type	Type of vector database provider to use.
ollama-buddy-menu-columns	Number of columns to display in the Ollama Buddy menu.
ollama-buddy-gemini-api-endpoint	Endpoint format for Google Gemini API.
ollama-buddy-fabric-pattern-categories	List of pattern categories to focus on when listing patterns.
ollama-buddy-rag-qdrant-api-key	API key for Qdrant server.
ollama-buddy-status-update-interval	Interval in seconds to update the status line with background operations.
ollama-buddy-fabric-update-on-startup	Whether to automatically update patterns when Emacs starts.
ollama-buddy-available-models	List of available models to pull from Ollama Hub.
ollama-buddy-grok-max-tokens	Maximum number of tokens to generate in the response.
ollama-buddy-highlight-models-enabled	Highlight model names with distinctive colors in Ollama Buddy buffers.
ollama-buddy-claude-max-tokens	Maximum number of tokens to generate in the response.
ollama-buddy-openai-marker-prefix	Prefix to indicate that a model is from OpenAI rather than Ollama.
ollama-buddy-history-enabled	Whether to use conversation history in Ollama requests.
ollama-buddy-grok-api-key	API key for accessing Grok services.
ollama-buddy-grok-default-model	Default Grok model to use.
ollama-buddy-concat-exclude-directories
ollama-buddy-claude-marker-prefix	Prefix used to identify Claude models in the model list.
ollama-buddy-roles-directory	Directory containing ollama-buddy role preset files.
ollama-buddy-codestral-temperature	Temperature setting for Mistral Codestral requests (0.0-2.0).
ollama-buddy-fabric-local-dir	Local directory where Fabric patterns will be stored.
ollama-buddy-show-history-indicator	Whether to show the history indicator in the header line.
ollama-buddy-context-size-thresholds	Thresholds for context usage warnings.
ollama-buddy-rag-chroma-url	URL for Chroma server.
ollama-buddy-rag-collection-name	Name of the vecdb collection to use for RAG.
ollama-buddy-mode-map	Keymap for ollama-buddy mode.
ollama-buddy-marker-prefix	Prefix used to identify Ollama models in the ollama-buddy interface.
ollama-buddy-codestral-marker-prefix	Prefix to indicate that a model is from Mistral Codestral rather than Ollama.
ollama-buddy-max-file-size	Maximum size for attached files in bytes.
ollama-buddy-fabric-patterns-subdir	Subdirectory within the Fabric repo containing the patterns.
ollama-buddy-context-display-type	How to display context usage in the status bar.
ollama-buddy-autocomplete-model
ollama-buddy-awesome-repo-url	URL of the Awesome ChatGPT Prompts GitHub repository.
ollama-buddy-user-prompts-directory	Directory where user system prompts are stored.
ollama-buddy-openai-api-endpoint	Endpoint for OpenAI chat completions API.
ollama-buddy-vision-models	List of models known to support vision capabilities.
ollama-buddy-params-active	Currently active values for Ollama API parameters.
ollama-buddy-embedding-model	The default model to use for generating embeddings.
ollama-buddy-codestral-api-endpoint	Endpoint for Mistral Codestral API.
ollama-buddy-openai-default-model	Default OpenAI model to use.
ollama-buddy-claude-default-model	Default Claude model to use.
ollama-buddy-params-modified	Set of parameters that have been explicitly modified by the user.
ollama-buddy-gemini-temperature	Temperature setting for Gemini requests (0.0-1.0).
ollama-buddy-current-session-name	The name of the currently loaded session.
ollama-buddy-host	Host where Ollama server is running.
ollama-buddy-curl-timeout	Timeout in seconds for curl requests.
ollama-buddy-image-formats	List of regular expressions matching supported image file formats.
ollama-buddy-streaming-enabled	Whether to use streaming mode for responses.
ollama-buddy-max-history-length	Maximum number of message pairs to keep in conversation history.
ollama-buddy-gemini-default-model	Default Gemini model to use.
ollama-buddy-default-model	Default Ollama model to use.
ollama-buddy-claude-temperature	Temperature setting for Claude requests (0.0-1.0).
ollama-buddy-vision-enabled	Whether to enable vision support for models that support it.
ollama-buddy-display-token-stats	Whether to display token usage statistics in responses.
ollama-buddy-show-context-percentage	Whether to show context percentage in the status bar.
ollama-buddy-claude-api-endpoint	Endpoint for Anthropic Claude API.
ollama-buddy-gemini-api-key	API key for accessing Google Gemini services.
ollama-buddy-openai-max-tokens	Maximum number of tokens to generate in the response.
ollama-buddy-claude-api-key	API key for accessing Anthropic Claude services.
ollama-buddy-params-profiles	Predefined parameter profiles for different usage scenarios.
ollama-buddy-awesome-local-dir	Local directory where Awesome ChatGPT Prompts will be stored.
ollama-buddy-params-defaults	Default values for Ollama API parameters.
ollama-buddy-mode-line-segment	Mode line segment for Ollama Buddy.
ollama-buddy-grok-temperature	Temperature setting for Grok requests (0.0-1.0).
ollama-buddy-port	Port where Ollama server is running.
ollama-buddy-default-register	Default register to store the current response when not in multishot mode.
ollama-buddy-fabric-repo-url	URL of the Fabric GitHub repository.
ollama-buddy-gemini-max-tokens	Maximum number of tokens to generate in the response.
ollama-buddy-modelfile-directory	Directory for storing temporary Modelfiles.
ollama-buddy-fallback-context-sizes	Mapping of model names to their default context sizes.
ollama-buddy-communication-backend	Communication backend to use for Ollama API requests.
ollama-buddy-codestral-max-tokens	Maximum number of tokens to generate in the response.
ollama-buddy-curl-executable	Path to the curl executable.
ollama-buddy-context-bar-chars	Characters used to draw the context progress bar.
ollama-buddy-supported-file-types	List of regex patterns for supported file types.
ollama-buddy-openai-temperature	Temperature setting for OpenAI requests (0.0-2.0).
ollama-buddy-convert-markdown-to-org	Whether to automatically convert markdown to `org-mode’ format in responses.
ollama-buddy-mode-hook	Hook run after entering or leaving `ollama-buddy-mode'.
ollama-buddy-gemini-marker-prefix	Prefix used to identify Gemini models in the ollama-buddy interface.
ollama-buddy-hide-reasoning	When non-nil, hide reasoning/thinking blocks from the stream output.
ollama-buddy-openai-api-key	API key for accessing OpenAI services.

Customize the package to the default startup using:

(setq ollama-buddy-current-model "qwen-4q:latest")

;; Change number of menu columns
(setq ollama-buddy-menu-columns 4)

;; Customize separators
(setq ollama-buddy-separator-1 "Your custom separator here")
(setq ollama-buddy-separator-2 "Another custom separator")

Available customization options:

Contributing

Contributions are welcome! Please:

Fork the repository
Create a feature branch
Commit your changes
Open a pull request

License

MIT License

Acknowledgments

Ollama for making local LLM inference accessible
Emacs community for continuous inspiration

Issues

Report issues on the GitHub Issues page

Alternative LLM based packages

To the best of my knowledge, there are currently a few Emacs packages related to Ollama, though the ecosystem is still relatively young:

llm.el (by Jacob Hacker)
- A more general LLM interface package that supports Ollama as one of its backends
- GitHub: https://github.com/ahyatt/llm
- Provides a more abstracted approach to interacting with language models
- Supports multiple backends including Ollama, OpenAI, and others
gptel (by Karthik Chikmagalur)
- While primarily designed for ChatGPT and other online services, it has experimental Ollama support
- GitHub: https://github.com/karthink/gptel
- Offers a more integrated chat buffer experience
- Has some basic Ollama integration, though it’s not the primary focus
chatgpt-shell (by xenodium)
- Primarily designed for ChatGPT, but has some exploration of local model support
- GitHub: https://github.com/xenodium/chatgpt-shell
- Not specifically Ollama-focused, but interesting for comparison
ellama
- TODO

Alternative package comparison

Let’s compare ollama-buddy to the existing solutions:

llm.el
- Pros:
  - Provides a generic LLM interface
  - Supports multiple backends
  - More abstracted and potentially more extensible
- Cons:
  - Less Ollama-specific
  - More complex configuration
  - Might have overhead from supporting multiple backends
ollama-buddy is more:
- Directly focused on Ollama
- Lightweight and Ollama-native
- Provides a more interactive, menu-driven approach
- Simpler to set up for Ollama specifically
gptel
- Pros:
  - Sophisticated chat buffer interface
  - Active development
  - Good overall UX
- Cons:
  - Primarily designed for online services
  - Ollama support is experimental
  - More complex architecture
ollama-buddy differentiates by:
- Being purpose-built for Ollama
- Offering a more flexible, function-oriented approach
- Providing a quick, lightweight interaction model
- Having a minimal, focused design
chatgpt-shell
- Pros:
  - Mature shell-based interaction model
  - Rich interaction capabilities
- Cons:
  - Not truly Ollama-native
  - Primarily focused on online services
  - More complex setup
ollama-buddy stands out by:
- Being specifically designed for Ollama
- Offering a simpler, more direct interaction model
- Providing a quick menu-based interface
- Having minimal dependencies
ellama
- TODO

Copying completion candidate to the clipboard

James Dyer — Thu, 30 Jan 2025 07:40:00 +0000

In my continuing quest to replace all my external use packages with my own elisp versions so I can still follow my current workflow on an air-gapped system, I would like to replace a single function I use often from embark

embark allows an action in a certain context, and there are a lot of actions to choose from, but I found I was generally using very few, so to remove my reliance on embark I think I can implement these actions myself.

The main one is to copy the current completion candidate. For example, I might be searching for a function name, so describe-function function for example, ha!, I just did it!, using describe-function to select describe-function and then copying to the clipboard to then paste in to this blog article!

Well that is it, so lets code it up:

(defun my-icomplete-copy-candidate ()
 "Copy the current Icomplete candidate to the kill ring."
 (interactive)
 (let ((candidate (car completion-all-sorted-completions)))
 (when candidate
 (kill-new (substring-no-properties candidate))
 (let ((copied-text candidate))
 (run-with-timer 0 nil (lambda ()
 (message "Copied: %s" copied-text)))
 (abort-recursive-edit)))))

(global-set-key (kbd "C-c ,") 'find-file-at-point)
(define-key minibuffer-local-completion-map (kbd "C-c ,") 'my-icomplete-copy-candidate)

Note of course that I use the built-in fido-mode and therefore icomplete so there might be possibly a different implementation if you were using something like vertico for example.

Also as a bonus, note that I have added another common embark action and that is to navigate to a file at point. Fortunately Emacs has this function built-in so I again bound to my former standard embark activation key.

Creating a small local elisp rainbow-mode solution

James Dyer — Sat, 25 Jan 2025 07:50:00 +0000

In this post, as part of my ongoing mission to replace all (or as many as possible) external packages with pure elisp, I’ll demonstrate how to implement a lightweight alternative to the popular rainbow-mode package, which highlights hex colour codes in all their vibrant glory. I use this quite often, especially when “ricing” my tiling window setup.

Instead of relying on rainbow-mode, lets create a custom Emacs function to colourize hex values in the buffer, along with another function to clear these highlights. We’ll also bind this functionality to modes like prog-mode, org-mode, and conf-space-mode.

Hexadecimal colour codes (like #ff0000 for red, #00ff00 for green, etc.) often appear in programming, configuration, or document files. Visualizing these colours directly within your buffer makes working with them much easier.

Here’s how you can create a simple function to overlay these colours in Emacs:

The following function highlights any 3 or 6 character hex colour codes it finds in the current buffer (e.g., #ff0000, #33aaff, #fff). It uses Emacs overlays to render the colour as the background of the matched text.

(defun my/rainbow-mode ()
 "Overlay colors represented as hex values in the current buffer."
 (interactive)
 (remove-overlays (point-min) (point-max))
 (let ((hex-color-regex "#[0-9a-fA-F]\\{3,6\\}"))
 (save-excursion
 (goto-char (point-min))
 (while (re-search-forward hex-color-regex nil t)
 (let* ((color (match-string 0))
 (overlay (make-overlay (match-beginning 0) (match-end 0))))
 (if (string-greaterp color "#888888")
 (overlay-put overlay 'face `(:background ,color :foreground "black"))
 (overlay-put overlay 'face `(:background ,color :foreground "white"))))))))

As an additional note, I have added a little logic regarding generating a contrasting foreground colour to help the hex text value remain prominent.

Sometimes you may want to remove all colour overlays from the current buffer. The following function clears the overlays applied by my/rainbow-mode:

(defun my/rainbow-mode-clear ()
 "Remove all hex color overlays in the current buffer."
 (interactive)
 (remove-overlays (point-min) (point-max)))

Now that we have created my/rainbow-mode, let’s make it automatically activate in relevant modes like prog-mode, org-mode, and conf-space-mode. You can achieve this by adding hooks to these modes:

(add-hook 'prog-mode-hook #'my/rainbow-mode)
(add-hook 'org-mode-hook #'my/rainbow-mode)
(add-hook 'conf-space-mode-hook #'my/rainbow-mode)

By doing this, whenever you open a buffer in a programming file, Org file, or certain configuration files, my/rainbow-mode will automatically highlight any hex colour codes present in the file.

And there we go!, by defining my/rainbow-mode, you can enjoy the benefits of colour-highlighting hex values in Emacs while staying true to a minimalist, package-free configuration!

Streamlining Navigation in Org-Mode using an adapted org-goto

James Dyer — Sat, 18 Jan 2025 11:08:00 +0000

Navigating through lengthy org files can sometimes feel cumbersome. To address this I have tweaked org-goto to be a little more usable through the minibuffer completion system to jump to any org heading.

I have been aware of the org-goto command for a while now, which technically, allows for the efficient navigation through an org file. Every now and then I give it a go, but it just feels clunky and some of the keybindings don’t quite feel intuitively Emacs for some reason.

Now my org files are getting more elaborate, I would like a better way to navigate and especially through the hierarchy of headings.

What about org-imenu-depth I hear you say! Well as far as I can tell, this allows stepping through to a defined subheading level but while going through multiple menu/hierarchical selection steps. For efficiency, I would like a way to flatten the subheadings for a one-shot completion selection method. This is where org-goto can actually be adapted to satisfy this need, and I think leverages the org refile menu system.

To achieve this, some variables will require changing, firstly:

(setq org-goto-interface 'outline-path-completionp)

The org-goto-interface variable defines the interface you use to navigate when calling org-goto. By default, org goto uses a mixed interface with direct completion and an alternative outline-based navigation using buffers. I prefer the outline-path-completionp setting, which provides a breadcrumb-like structure for easier navigation through the minibuffer completion system.

By default, Org mode’s outline-path interface works in steps, which means you select one heading level at a time. I find this behaviour a bit clunky, especially for larger files. Fortunately, you can disable this step-by-step behaviour by setting org-outline-path-complete-in-steps to nil which flattens the presented org goto heading list when activated so you can see the full list of headings/subheadings in a single step and therefore be able to navigate directly to your desired location.

(setq org-outline-path-complete-in-steps nil)

Lets demonstrate how this now works with an example.

Given the following org:

* Heading 1
...
* Heading 2
...
** Subheading 2.1
...
* Subheading 3
...
** Subheading 3.1
...
*** Subheading 3.1.1

imenu would just allow navigation to leaf nodes and not the higher subdirectories.

(Note : I use fido-mode=/=icomplete):

Here is the minibuffer menu presented when imenu is activated by default:

(Heading.1 | Heading.2 | *Rescan* | Subheading.3)

For example, I can navigate to Heading 1 but what about Heading 2 or Heading 3?, when selecting these headings that have subheadings it will take me into further leaf node menus for selection.

This is where the setup above for org-goto comes in handy as it now presents the following:

{Heading 2/ | Heading 2/Subheading 2.1/ | Heading 1/ | Subheading 3/ | Subheading 3/Subheading 3.1/ | Subheading 3/Subheading 3.1/Subheading 3.1.1/}

Where of course the minibuffer completion system can complete to not just the leaf nodes but also the higher level subheadings, allowing navigation to any org heading!

Ediff Comparing Regions

James Dyer — Wed, 08 Jan 2025 15:30:00 +0000

ediff is one of my favourite tools in Emacs and I have recently found myself not only using ediff-buffers and vc-ediff often but also now having the need to compare two regions.

For example, when developing new Elisp functions, I generally modify the bottom of my tangled init file and then evaluate/edit as necessary, or sometimes through the scratch buffer.

However, for something more complex, for example, at the moment, I am trying to generate an RSS feed from my Hugo-based blog’s Org file through org-publish. In this case, I prefer creating a separate directory where I can experiment with example files, generated files, and temporarily manage everything under version control.

At the end of development, I could simply paste my function(s) back into my main configuration, however, as a software engineer, I am accustomed to using merging tools, so what better way to handle this than with ediff

Given my development functions and my init file, I can’t compare entire files to copy/merge the changes across, and VC in this case is not helpful. So, how do I compare two regions? In fact, is it even possible in Emacs?

Well, yes, yes it is! (of course)

ediff-regions-linewise

Run Ediff on a pair of regions in specified buffers. BUFFER-A and BUFFER-B are the buffers to be compared. Regions (i.e., point and mark) can be set in advance or marked interactively. Each region is enlarged to contain full lines.

and my keybinding is:

(global-set-key (kbd "M-s +") #'ediff-regions-linewise)

Note: at the moment I only ever run ediff-regions-linewise but the documentation recommends using ediff-regions-wordwise for smaller regions. For this example I shall be using ediff-regions-linewise only.

Documentation for ediff-regions-wordwise

The ediff-regions-linewise function is effective for large regions, over 100-200 lines.

For small regions, use ‘ediff-regions-wordwise’.

Initially, I prefer to have a horizontal split with the two files containing the regions I would like to compare, and then place the point in the left-hand window.

When ediff-regions-linewise is then activated, that is the order the regions are set up, from left to right.

Note: According to the documentation, it seems possible to set up the two regions using marks before the call, after which you will go directly into an ediff comparison rather than the interactive region described below. However, I have not yet been able to get the region comparison to work this way.

Ok, lets do a region comparison!

Run
- Open both buffers side-by-side, Buffer A : Buffer B
- Run M-x ediff-regions-linewise
- Select each side-by-side buffer, by <RET>, <RET>
Mark Buffer A’s Region
- When prompted for “Region A:”, Buffer A will be automatically switched to
- Now mark the region for comparison
- Once the region is marked, hit C-M-c
Mark Buffer B’s Region
- Similarly, when prompted for “Region B:”, Buffer B will be automatically switched to
- Now mark the region for comparison
- Once the region is marked, hit C-M-c
Now the usual familiar ediff comparison begins.

Here is a little visual example set up with a simple paragraph difference:

In this case Buffer A and Buffer B are set up side-by-side and with the process for a region comparison as described above on 2. Mark Buffer A’s Region that I have deliberately made slightly different for Buffer B.

Here is the comparison result:

I have something that seems to work for me at the moment, but I would really like to fully understand the difference between a linewise and a wordwise comparison. I understand that wordwise comparison could be computationally expensive on large blocks, but what benefits do I gain from using a smaller wordwise comparison compared to a linewise comparison?

Also, although the interactive region selection works well, I really want to figure out how to set up the regions initially.

If anyone knows answers to these questions, just drop in a comment!

Emacs Quick Window Pt 4 - Further Tweaks

James Dyer — Fri, 03 Jan 2025 20:20:00 +0000

Previously, my/quick-window-jump was geared mostly toward managing two or more windows. The behaviour was straightforward:

If two windows were open, the function would directly jump to the other window.
For more than two windows, a key selection interface would allow you to pick a window to switch to.

However, the function didn’t handle a single-window scenario intelligently. A horizontal split from a single window is something I do very frequently, by frequently, I mean at least every minute! This split is currently bound to its own keybinding, but couldn’t my ace-window defun clone do this? For example, I find that the transition from a single window to a split never happens vertically for me, so why not make my/quick-window-jump perform a horizontal split from a single window and then move the point to that window?

In addition, it is very rare for me to vertically split into more than two columns. I could probably drop my current horizontal split keybinding now. If I do require another horizontal split, the default C-x 3 is already bound to muscle memory.

Lets take this function to the next level of convenience, with a very simple change, simply an extra (length window-list) and the relevant logic.

Below is the updated implementation of my/quick-window-jump:

(defun my/quick-window-jump ()
 "Jump to a window by typing its assigned character label.
If there is only a single window, split it horizontally.
If there are only two windows, jump directly to the other window."
 (interactive)
 (let* ((window-list (window-list nil 'no-mini)))
 (cond
 ;; If there is only a single window, split it horizontally.
 ((= (length window-list) 1)
 (split-window-horizontally)
 (other-window 1)) ;; Move focus to the new window immediately after splitting.
 ;; If there are only two windows, switch to the other one directly.
 ((= (length window-list) 2)
 (select-window (other-window-for-scrolling)))
 ;; Otherwise, present the key selection interface.
 (t
 (let* ((my/quick-window-overlays nil)
 (sorted-windows (sort window-list
 (lambda (w1 w2)
 (let ((edges1 (window-edges w1))
 (edges2 (window-edges w2)))
 (or (< (car edges1) (car edges2))
 (and (= (car edges1) (car edges2))
 (< (cadr edges1) (cadr edges2))))))))
 (window-keys (seq-take '("j" "k" "l" ";" "a" "s" "d" "f")
 (length sorted-windows)))
 (window-map (cl-pairlis window-keys sorted-windows)))
 (setq my/quick-window-overlays
 (mapcar (lambda (entry)
 (let* ((key (car entry))
 (window (cdr entry))
 (start (window-start window))
 (overlay (make-overlay start start (window-buffer window))))
 (overlay-put overlay 'after-string
 (propertize (format "[%s]" key)
 'face '(:foreground "white" :background "blue" :weight bold)))
 (overlay-put overlay 'window window)
 overlay))
 window-map))
 (let ((key (read-key (format "Select window [%s]: " (string-join window-keys ", ")))))
 (mapc #'delete-overlay my/quick-window-overlays)
 (setq my/quick-window-overlays nil)
 (when-let ((selected-window (cdr (assoc (char-to-string key) window-map))))
 (select-window selected-window))))))))

The updated my/quick-window-jump function now adapts to any window configuration dynamically. Here is now an overview on how it now works:

Single Window? Split It Automatically
- If there’s only one window open, the function splits it horizontally and shifts focus to the new window.
Two Windows? Still Jump Directly
- The behaviour for two windows remains unchanged. It efficiently switches focus to the other window directly without inefficiencies.
More Than Two Windows? Key Selection Interface
- When multiple windows are open, the function presents the familiar key selection interface, allowing you to jump exactly where you intend.

Will there be more tweaks?, not sure, but this is the advantage of now creating my own defun for this piece of functionality!

Exploring Static Website Publishing with Org Publish

James Dyer — Fri, 27 Dec 2024 10:10:00 +0000

As someone who enjoys using Emacs for almost everything, I recently began exploring an alternative Emacs-native method for publishing static websites.

Currently, I use ox-hugo to build a static site from a single Org file, and it works beautifully for exporting content to Hugo-compatible Markdown. However, I wanted to create a backup web generation system entirely within Emacs that doesn’t rely on external tools like Hugo and might fit into my overarching Emacs Enhancements project concept.

My Emacs Enhancements project focuses on replacing significant external packages that I commonly use with a collection of simple Elisp functions and built-in functionality. This approach is ideal for situations where I run Emacs on an air-gapped system or even on Windows, where I have found package management to be somewhat unreliable. You can check out my progress on GitHub.

So, how do I replace Hugo/ox-hugo? Well, I finally got around to experimenting with the powerful org-publish system. I say “finally” because I’ve had my eye on this for quite a while, but at no point in the past did I have the time to invest in learning it. Now, during the festive period, I have my laptop and potentially some downtime so maybe now is the time!

This post documents my work in progress journey of setting up an Emacs-based publishing workflow using org-publish to export to HTML.

Why Org-Publish over ox-hugo?

While ox-hugo provides extensive functionality to structure and export content seamlessly for Hugo-based static sites, I found these motivations to explore org-publish:

Native Emacs Solution: Keeping everything within the Emacs ecosystem.
Backup: Ensures I have a non-Hugo-dependent HTML web site generation backup.
Customizability: Leverage fine-grained control over publishing directory structures and formats from within Emacs elisp.

That said, this isn’t a replacement for ox-hugo, but an experiment to see how efficient a pure Emacs approach can be.

Project Setup Overview

Using a Monolithic Org File: My starting file, emacs--all.org, contains all blog posts under separate headings.
Split the Org File into Multiple Smaller Files: For compatibility with org-publish, I wrote a utility to split the file. This allows each blog post to be processed independently.
Use org-publish-project-alist: Define a multi-step pipeline for splitting, exporting HTML, and processing images.

Here’s how I tackled each step in detail:

Step 1: Splitting the Monolithic Org File

The first hurdle was enabling org-publish to work with my single Org file. Since org-publish usually expects individual files to process, I created a custom function, my-org-publish-split-headings. This function splits the top-level headings marked as DONE into separate files, each prefixed with the date from a property (e.g., :EXPORT_HUGO_LASTMOD:).

Splitting File Logic

Hopefully, this defun is commented well enough to be almost self-documenting!

(defun my-org-publish-split-headings (plist filename pub-dir)
 "Split an Org file into separate files, each corresponding to a top-level heading
that is marked as DONE.

Each file name is prefixed with the date in YYYYMMDD format extracted from the
:EXPORT_HUGO_LASTMOD: property. PLIST is the property list for the publishing
process, FILENAME is the input Org file, and PUB-DIR is the publishing directory."
 (with-temp-buffer
 (insert-file-contents filename) ;; Load the content of the current Org file
 (goto-char (point-min))
 (let ((heading-level 1) ;; Level of the top-level heading to split by
 prev-start heading-title sanitized-title output-file lastmod-date)
 ;; Iterate over all top-level headings
 (while (re-search-forward (format "^\\*\\{%d\\} \\(?:\\([[:upper:]]+\\) \\)?\\(.*\\)" heading-level) nil t)
 (let ((todo-keyword (match-string 1)) ;; Extract the TODO keyword (if it exists)
 (heading-title (match-string 2))) ;; Extract the title of the heading
 ;; Process only headings marked as DONE
 (when (and todo-keyword (string-equal todo-keyword "DONE"))
 (setq prev-start (match-beginning 0)) ;; Start of the current heading
 (setq sanitized-title (when heading-title
 (replace-regexp-in-string "[^a-zA-Z0-9_-]" "_" heading-title))) ;; Sanitize title
 ;; Extract the :EXPORT_HUGO_LASTMOD: property for the current section
 (save-excursion
 (when (re-search-forward ":EXPORT_HUGO_LASTMOD: +\\(<.+>\\)" (save-excursion (re-search-forward "^\\* " nil t) (point)) t)
 (let* ((raw-lastmod (match-string 1)) ;; Extract the timestamp string (e.g., "<2024-12-08 08:37>")
 (date-elements (when (string-match "<\\([0-9]+\\)-\\([0-9]+\\)-\\([0-9]+\\)" raw-lastmod)
 (list (match-string 1 raw-lastmod) ;; Year
 (match-string 2 raw-lastmod) ;; Month
 (match-string 3 raw-lastmod))))) ;; Day
 (setq lastmod-date (when date-elements
 (apply #'concat date-elements))))))
 ;; Default to "00000000" if no valid lastmod-date is found
 (setq lastmod-date (or lastmod-date "00000000"))
 ;; Find the end of this section (right before the next top-level heading)
 (let ((section-end (save-excursion
 (or (re-search-forward (format "^\\*\\{%d\\} " heading-level) nil t)
 (point-max))))) ;; End of current section or end of file
 ;; Only proceed if sanitized title exists and is valid
 (when (and sanitized-title (not (string-empty-p sanitized-title)))
 ;; Create the output file name (prepend the date)
 (setq output-file (expand-file-name (format "%s-%s.org" lastmod-date sanitized-title) pub-dir))
 ;; Write the section content (from prev-start to section-end)
 (write-region prev-start section-end output-file)
 (message "Wrote %s" output-file)))))))
 ;; Return nil to indicate successful processing
 nil))

I will go into more detail about how I set this up in a future post and how I decided on a split org-file naming convention.

Step 2: Org-Publish Configuration

After splitting the file, I defined the publishing pipeline in org-publish-project-alist. Here’s what each part does:

split-emacs:
- Runs the custom splitting function (my-org-publish-split-headings).
- Takes the original monolithic Org file and generates smaller Org files in a designated directory.
blog-posts-emacs:
- Processes these generated Org files and exports them to HTML.
- Adds metadata such as preamble, postamble, and custom .css links for styling.
- Automatically generates a “sitemap” for blog indexing.
images-emacs:
- Publishes related images to the target directory.
blog:
- Meta-project to combine all the phases (split-emacs, blog-posts-emacs, images-emacs).

`org-publish-project-alist`

(require 'ox-publish)
;;
(setq org-publish-project-alist
 '(("split-emacs"
 :base-directory "~/DCIM/content"
 :base-extension "org"
 :publishing-directory "~/DCIM/content/split/emacs"
 :exclude ".*"
 :include ("emacs--all.org")
 :publishing-function my-org-publish-split-headings
 :recursive nil)
 ("blog-posts-emacs"
 :base-directory "~/DCIM/content/split/emacs"
 :base-extension "org"
 :publishing-directory "~/publish/hugo-emacs/site/static/public_html"
 :publishing-function org-html-publish-to-html
 :recursive t
 :section-numbers nil
 :with-toc nil
 :html-preamble t
 :html-postamble t
 :auto-sitemap t
 :sitemap-filename "index.org"
 :sitemap-title "the DyerDwelling"
 :html-head "<link rel=\"stylesheet\"
 href=\"../assets/css//bootstrap.css\"
 type=\"text/css\"/>\n
 <link rel=\"stylesheet\"
 href=\"../assets/css//style-ignore.css\"
 type=\"text/css\"/>"
 :sitemap-function my-sitemap-format
 :sitemap-sort-files alphabetically)
 ("images-emacs"
 :base-directory "~/DCIM/content/emacs"
 :base-extension "jpg\\|gif\\|png"
 :recursive t
 :publishing-directory "~/publish/hugo-emacs/site/static/public_html/emacs"
 :publishing-function org-publish-attachment)
 ("blog" ;; Meta-project to combine phases
 :components ("split-emacs" "images-emacs" "blog-posts-emacs"))))

Conclusion

Here is the generated site: https://www.emacs.dyerdwelling.family/public_html/

This was a simple introduction to my approach to using org-publish to provide an alternative web publishing option for my blog, while I’m still refining this workflow, the combination of a monolithic Org file for writing and org-publish for exporting HTML is already proving quite effective as a pure Emacs-powered alternative.

Calculate Number Of Days Between Two Dates

James Dyer — Thu, 19 Dec 2024 13:21:00 +0000

Just a very quick one today.

I recently needed to find the number of days between two dates. I thought this would be easy in Emacs, and indeed it was, but as with most things in Emacs, you need to know exactly what you’re doing. Here is the method I used:

 M-x =calendar=
Navigate to the start date
Set mark
Navigate to the end date
M-x =calendar-count-days-region=
OR
M-=

Note that the count is inclusive of the mark, the documentation says:

It is bound to M-=.

Count the number of days (inclusive) between point and the mark.

That is all. 🙂

Emacs Quick Window Pt 3 - jumping between two windows

James Dyer — Fri, 13 Dec 2024 20:15:00 +0000

The original implementation of my/quick-window-jump worked perfectly for multi-window setups. It enabled you to assign character labels to each window, display them as overlays within the windows themselves, and jump to your desired window by typing its corresponding key. However, for setups with just two windows (a very common scenario in Emacs), this process felt unnecessarily complicated. Why go through the entire label-assignment process when a single key press could suffice?

This latest tweak to my/quick-window-jump introduces a simple improvement and in fact is currently what ace-window does: direct switching for two windows. If there are exactly two windows open, the function now skips the overhead of key prompts and overlay creation. Instead, it switches directly to the other window, this seems more logical to me, why the extra key when it is obvious where the point is going to jump to?

Here’s the core logic for handling two windows:

(let* ((window-list (window-list nil 'no-mini)))
 (if (= (length window-list) 2)
 ;; If there are only two windows, switch to the other directly.
 (select-window (other-window-for-scrolling))
 ;; Otherwise, show the key selection interface.
 ...))

and here is the updated function:

(defun my/quick-window-jump ()
 "Jump to a window by typing its assigned character label.
 If there are only two windows, jump directly to the other window."
 (interactive)
 (let* ((window-list (window-list nil 'no-mini)))
 (if (= (length window-list) 2)
 ;; If there are only two windows, switch to the other one directly.
 (select-window (other-window-for-scrolling))
 ;; Otherwise, show the key selection interface.
 (let* ((my/quick-window-overlays nil)
 (sorted-windows (sort window-list
 (lambda (w1 w2)
 (let ((edges1 (window-edges w1))
 (edges2 (window-edges w2)))
 (or (< (car edges1) (car edges2))
 (and (= (car edges1) (car edges2))
 (< (cadr edges1) (cadr edges2))))))))
 (window-keys (seq-take '("j" "k" "l" ";" "a" "s" "d" "f")
 (length sorted-windows)))
 (window-map (cl-pairlis window-keys sorted-windows)))
 (setq my/quick-window-overlays
 (mapcar (lambda (entry)
 (let* ((key (car entry))
 (window (cdr entry))
 (start (window-start window))
 (overlay (make-overlay start start (window-buffer window))))
 (overlay-put overlay 'after-string
 (propertize (format "[%s]" key)
 'face '(:foreground "white" :background "blue" :weight bold)))
 (overlay-put overlay 'window window)
 overlay))
 window-map))
 (let ((key (read-key (format "Select window [%s]: " (string-join window-keys ", ")))))
 (mapc #'delete-overlay my/quick-window-overlays)
 (setq my/quick-window-overlays nil)
 (when-let ((selected-window (cdr (assoc (char-to-string key) window-map))))
 (select-window selected-window)))))))

Emacs Core Window Jumping With Visual Feedback

James Dyer — Tue, 10 Dec 2024 14:15:00 +0000

Already I think I can improve my/quick-window-jump: which was a window jumping mechanism I created in my previous post which uses a unique key identifier for window navigation just like ace-window but condensed into a minimal elisp defun implementation.

While the original implementation worked, I recently revisited and refined it to improve its modularity, visual feedback, and overall usability.

The main headline of the improvement is porting the ace-window window label identifier navigation mechanism using overlays!, see below:

In this post, I’ll detail the evolution of my/quick-window-jump, highlighting the changes made to simplify the code, provide immediate visual indicators, and improve the end-user experience.

The Original Implementation

Original Code

(defun my/quick-window-jump ()
 "Jump to a window by typing its assigned character label.
Windows are labeled starting from the top-left window and proceed top to bottom left to right."
 (interactive)
 (let* ((window-list (my/get-windows)) ; Get sorted list of windows
 (window-keys (seq-take '("j" "k" "l" ";" "a" "s" "d" "f") ; Assign key labels
 (length window-list)))
 (window-map (cl-pairlis window-keys window-list)) ; Create key-to-window map
 (key (read-key (format "Select window [%s]: " (string-join window-keys ", ")))))
 (if-let ((selected-window (cdr (assoc (char-to-string key) window-map)))) ; Jump to selected window
 (select-window selected-window)
 (message "No window assigned to key: %c" key))))

(defun my/get-windows ()
 "Return a list of windows in the current frame, ordered from top to bottom, left to right."
 (sort (window-list nil 'no-mini)
 (lambda (w1 w2)
 (let ((edges1 (window-edges w1))
 (edges2 (window-edges w2)))
 (or (< (car edges1) (car edges2)) ; Compare top edges
 (and (= (car edges1) (car edges2)) ; If equal, compare left edges
 (< (cadr edges1) (cadr edges2))))))))

While functional, several downsides existed in this implementation:

Separation of Logic: The my/get-windows function added an extra layer of abstraction that wasn’t strictly necessary, as sorting logic could be directly embedded into the main function.
Lack of Visual Feedback: The function provided no immediate indicator of which windows corresponded to which keys. Users had to guess or manually map the output of the key labels to the positions in their frame layout.

The New and Improved Implementation

The updated version of my/quick-window-jump refines the original function by:

Inlining Window Sorting Logic: Sorting logic is now part of the main function rather than relying on a separate helper, simplifying maintenance and reducing cognitive overhead.
Adding Overlay Labels: Temporary overlays are added to each window, displaying the assigned key visually within the actual window. This makes it easier for users to identify which key corresponds to which window without having to manually figure it out.

Here’s the updated code:

Improved Code

(defun my/quick-window-jump ()
 "Jump to a window by typing its assigned character label.
Windows are labeled starting from the top-left window and proceeding top to bottom, then left to right."
 (interactive)
 (let* ((my/quick-window-overlays nil) ; Temporary list for overlays
 ;; Sort windows by position (top-to-bottom, left-to-right)
 (window-list (sort (window-list nil 'no-mini)
 (lambda (w1 w2)
 (let ((edges1 (window-edges w1))
 (edges2 (window-edges w2)))
 (or (< (car edges1) (car edges2))
 (and (= (car edges1) (car edges2))
 (< (cadr edges1) (cadr edges2))))))))
 ;; Assign key labels to windows
 (window-keys (seq-take '("j" "k" "l" ";" "a" "s" "d" "f")
 (length window-list)))
 (window-map (cl-pairlis window-keys window-list))) ; Create map of keys to windows
 ;; Add overlays to display key labels in each window
 (setq my/quick-window-overlays
 (mapcar (lambda (entry)
 (let* ((key (car entry))
 (window (cdr entry))
 (start (window-start window)) ; Start position of window
 (overlay (make-overlay start start (window-buffer window)))) ; Create overlay
 (overlay-put overlay 'after-string ; Add a visual label
 (propertize (format "[%s]" key)
 'face '(:foreground "white"
 :background "blue"
 :weight bold)))
 (overlay-put overlay 'window window) ; Associate overlay with window
 overlay))
 window-map))
 ;; Read key input from user
 (let ((key (read-key (format "Select window [%s]: " (string-join window-keys ", ")))))
 ;; Clear overlays and reset
 (mapc #'delete-overlay my/quick-window-overlays)
 (setq my/quick-window-overlays nil)
 ;; Select window based on key or show error
 (when-let ((selected-window (cdr (assoc (char-to-string key) window-map))))
 (select-window selected-window)))))

Key Improvements

Eliminating Redundancy By folding the my/get-windows functionality into my/quick-window-jump, the updated function is now self-contained. This reduces dependency on external helpers and makes the logic easier to follow.
Enhancing User Experience with Visual Overlays The use of temporary overlays provides immediate, intuitive feedback by displaying key mappings directly inside the appropriate windows. This reduces guesswork and makes navigation significantly faster.

Each window is temporarily labeled with a key, using the following visual attributes:
- Foreground: White for contrast.
- Background: Blue for prominence.
- Bold Font: For easy readability.

Why These Changes Matter

Well I guess they don’t really, it’s just for me and its just for fun! 😀

Reduced Mental Burden: The new approach lets users navigate windows without having to remember or deduce key-to-window mappings. Visual feedback ensures immediate understanding of the layout.
Improved Modularity: By embedding all functionality into a single function and handling cleanup directly, the updated implementation is more modular and self-contained.
Enhanced Readability and Maintainability: Fewer moving parts and a more streamlined design make the function easier to maintain or extend in the future.

Core Emacs Init Without External Packages

James Dyer — Fri, 06 Dec 2024 15:00:00 +0000

I thought I would share a simple concept that I have found very beneficial: creating an Emacs init file that remains almost fully functional for my use but doesn’t include any external packages!

This setup benefits two main use cases. The first is when using Emacs at work without internet access, and the second is configuring it for use on Windows (with an internet connection). For some reason, my Windows version always seems to struggle to connect to MELPA/ELPA for package downloads, prompting me to resort to an initial complete local repository download. Even then, I still encounter some inconsistencies. I don’t often use the native Windows Emacs version anyway, and now that WSL is mature enough, I know a fully functioning version of Emacs can run seamlessly.

Anyway enough with the blithering.

I have realized that over the years, I have accumulated many Elisp snippets that can actually replace several packages I have downloaded from MELPA.

For example, while I couldn’t live without ace-window, I only primarily use it for the window-jumping functionality. Now that I am familiar with the typical positions of the key identifiers in my window layout, I thought I would simply write my own implementation in Elisp:

(defun my/quick-window-jump ()
 "Jump to a window by typing its assigned character label.
 Windows are labeled starting from the top-left window and proceed top to bottom left to right."
 (interactive)
 (let* ((window-list (my/get-windows))
 (window-keys (seq-take '("j" "k" "l" ";" "a" "s" "d" "f")
 (length window-list)))
 (window-map (cl-pairlis window-keys window-list))
 (key (read-key (format "Select window [%s]: " (string-join window-keys ", ")))))
 (if-let ((selected-window (cdr (assoc (char-to-string key) window-map))))
 (select-window selected-window)
 (message "No window assigned to key: %c" key))))

(defun my/get-windows ()
 "Return a list of windows in the current frame, ordered from top to bottom, left to right."
 (sort (window-list nil 'no-mini)
 (lambda (w1 w2)
 (let ((edges1 (window-edges w1))
 (edges2 (window-edges w2)))
 (or (< (car edges1) (car edges2)) ; Compare top edges
 (and (= (car edges1) (car edges2)) ; If equal, compare left edges
 (< (cadr edges1) (cadr edges2))))))))

(global-set-key (kbd "M-a") #'my/quick-window-jump)

So the ace-window jumping functionality is now usable in an environment without access to MELPA!

I thought I would present my “no package” Emacs config piece by piece one blog post at a time, showcasing 90% of the functionality I typically use day-to-day and how I have managed to either write some elisp, found out a built-in option, or adapted my workflow in some way.

I still have my “full-fat” version, of course, but I have now based it on the core version (hence the name) and added extra things like magit, etc.

However, magit is a good example on something I think I might be able to remove soon to switch to the built-in Emacs VC. I successfully use it at work with both Git and Subversion!

If you are interested in seeing the full “no fat” version, have a ganders at: https://github.com/captainflasmr/Emacs-core

There will be more to come on this topic in the coming weeks… 😀

Shrinking and Widening Org Tables

James Dyer — Thu, 28 Nov 2024 13:02:00 +0000

This post is more of a note to myself, something I can store in my single emacs blog org file, so if I forget again, I can quickly search.

I keep forgetting the keybinding to shrink and expand an org table.

I often define tables to have a narrower width than content using the <num> concept in the top line of the table, but when I want to expand, I just can’t remember the keybinding.

A search in *help* for org-table-shrink and org-table-expand reveals nothing!

Anyway, here is a note to myself:

 C-c TAB (translated from C-c <tab>) runs the command org-ctrl-c-tab
(found in org-mode-map), which is an interactive native-compiled
Lisp function in ‘org.el’.
It is bound to C-c TAB.
(org-ctrl-c-tab &optional ARG)
Toggle columns width in a table, or show children. Call
‘org-table-toggle-column-width’ if point is in a table. Otherwise
provide a compact view of the children. ARG is the level to hide.

For clarity, within an Org table, pressing C-c <TAB> will toggle shrink/expand the state of the column that the point is currently in.

C-u C-c <TAB> will shrink all columns AND

C-u C-u C-c <TAB> will expand all columns

Right, that is a note, just for me 😀

Reducing Friction when Copying Whole Buffer To Kill Ring

James Dyer — Mon, 18 Nov 2024 10:24:00 +0000

Just a quick one today.

In keeping with the ongoing effort to reduce friction in the venerable Emacs text editor, I realized that a common action I often perform is copying the entire contents of the buffer, usually for pasting elsewhere.

To perform this I have chained together some emacs commands, namely (mark-whole-buffer) and then (kill-ring-save)

The problem with pushing the buffer to the kill ring in this manner is that I lose the current cursor position/point and end up using isearch to navigate my way back. Strangely, it is only recently that I have found this annoying!

There are a few options to address this:

Use Emacs marks
Create a macro
Create a defun

Initially I tried the setting mark option meaning that I C-<SPC> C-<SPC> to set the mark at the current position and then C-u C-<SPC> to pop back to my previous mark set. The only issue is that (mark-whole-buffer) creates a mark at the end of the selected region and my first mark pop would be to this position, so I have to mark pop again.

The benefit of this approach is that I will start becoming more familiar with setting marks and navigating more efficiently within Emacs, which I really think I should learn. However, it all feels a little clunky, and you know what? I’m just going to write a simple elisp defun and bind it.

save-excursion, in this case, can be extremely useful!

(defun my/copy-buffer-to-kill-ring ()
 "Copy the entire buffer to the kill ring without changing the point."
 (interactive)
 (save-excursion
 (kill-ring-save (point-min) (point-max))))

(bind-key* (kbd "M-s z") #'my/copy-buffer-to-kill-ring)

Org Table From Org Headings using a Babel Block

James Dyer — Tue, 12 Nov 2024 20:20:00 +0000

In this post, I’ll walk you through how I use an Org Babel block to generate a dynamic Org table based on Org headings.

This approach is handy for anyone who wishes to programmatically extract information from an Org file (such as TODO states, tags, and content) and automatically format it as a neatly structured Org table. You can then export this table to various formats — like HTML, Markdown, or LaTeX — with built-in Org mode support.

At work, I’m currently using Emacs and Confluence, so my idea was to figure out how to get an org file into a Confluence post in a structured manner. For the particular task I’m working on, I’ve decided that I would like to convert an org file into a table. The table format essentially flattens the information presented by org structured text, and putting it as a table in Confluence also has the advantage of column sorting and filtering.

This seems for the task in hand the most efficient way of representing a certain set of data. I will have the advantage of always working within a familiar org document at the basic text level, leveraging all those years of Emacs muscle memory and as always forming the markup base for a myriad of export options.

However, I’m going to devise another method of export, lets see if I can find an effectual way to convert an org file into a table that can be efficiently used in Confluence.

I did some research and thought that maybe the org column mode could be somewhat useful. It’s tabular, right? Can’t I just grab that data and put it somewhere? Well, from what I can gather, it’s mainly for more easily representing properties and uses overlays, which are not conducive to easy export.

A dynamic block looks quite interesting and seems to be more for representing some form of dynamic data that is consistently updated and is tied to an org document. I think a pattern of tabular representation can be generated using this form and I might take a look at this in the future but for now it doesn’t quite seem like the incremental learning opportunity I’m looking for.

And another option?, well that is to play around with an ox org back-end?, for example generating an html table and tailoring to my own needs. This might be a bit too advanced for me at this stage, I think I will stick with the approach I decided on below which is to create an org babel block and generate a table through the output header parameter :results table mechanism.

Of course I am familiar with org babel blocks, it is how I generate my Emacs init file through the tangle mechanism, but I didn’t quite realise just how powerful it could be. My idea here is to parse the current org buffer with a babel block and output an org table simply as a string which would be interpreted as an org table in org-mode, that would work right?. Well yes, yes it did work, I essentially just kept appending row strings as you would see in a typical org table, separated by the pipe character. The code however was not particularly efficient, I would gather (push) all the relevant org items onto a list and then loop over them to construct the org table string. As far as I was aware at the time the only babel mechanism for generation was though a form of pushing textual data to stdout which would then appear in the current buffer to be interpreted in whichever way you want according to the mode.

I stumbled on to a better solution however. I had already done the hard work of constructing a list of lists, with each sublist representing a row, it turns out that I can just return this list from the babel block and if I have the babel output header parameters set as :results table the list will be interpreted as a table!

Well lets try this out…

Note: the following examples will all be a babel block with the following header parameters defined:

#+begin_src emacs-lisp :results table :exports both

(let ((rows '()))
 (push (list "1: first row" "2: first row") rows)
 rows)

| 1: first row | 2: first row |

That is a table with a single row!

Lets expand…

(let ((rows '()))
 (push (list "1: first row" "2: first row") rows)
 (push (list "1: second row" "2: second row") rows)
 rows)

| 1: second row | 2: second row |
| 1: first row | 2: first row |

So now I have a simple mechanism for adding multiple rows.

Hang on!, the rows are not the order I expected, lets reverse.

(let ((rows '()))
 (push (list "1: first row" "2: first row") rows)
 (push (list "1: second row" "2: second row") rows)
 (reverse rows))

| 1: first row | 2: first row |
| 1: second row | 2: second row |

What about the table header?, this took a while to figure out, but I think I have it.

(let ((rows '()))
 (push (list "1: first row" "2: first row") rows)
 (push (list "1: second row" "2: second row") rows)
 (setq rows (reverse rows))
 (push 'hline rows)
 rows)

|---------------+---------------|
| 1: first row | 2: first row |
| 1: second row | 2: second row |

Well that is the header line, but there is no header!!

(let ((rows '())
 (header (list "col1" "col2")))
 (push (list "1: first row" "2: first row") rows)
 (push (list "1: second row" "2: second row") rows)
 (setq rows (reverse rows))
 (push 'hline rows)
 (cons header rows))

| col1 | col2 |
|---------------+---------------|
| 1: first row | 2: first row |
| 1: second row | 2: second row |

I think I have figured it out now, so the next aspect I need to consider is how to pick up the org elements. It seems a common approach is to use org-map-entries which steps though each headline, seemingly actually within the buffer itself and some helper functions are available which can be used to extract the data. For example, org-element-at-point, org-outline-level, org-get-tags, e.t.c, I am aware that there is a more formal API type of method where a syntactical tree can be made available through org-element-parse-buffer but that maybe is for another time. Lets move ahead with the org babel, table output, org list construction through org-map-entries implementation.

The Task - Collecting Headings and Outputting in a Table

The goal is simple: outline tasks with various headings, nesting levels, TODO states, tags, and content in an Org file, and use that information to generate an Org table using an Emacs Lisp Org Babel block. This allows us to extract metadata from headings into a well-structured table with a corresponding header row.

Each Org heading will be converted into a table row in the following format:

Title: The full heading, including indentation to represent the level hierarchy.
TODO State: The TODO keyword (like TODO, DONE, or other custom states) associated with the heading.
Tags: Any Org tags associated with the heading.
Contents: The content that immediately follows the heading.

The Code

The following Emacs Lisp code in an Org Babel block which scans the Org file, collects the required information from all headings, and formats it into a table. Let’s break it down step-by-step:

Org Babel Block: Automatic Table Generation

(let ((rows)
 (header (list "Title" "TODO" "Tags" "Contents"))
 (table-rows '())
 (max-level 0))
 (org-map-entries
 (lambda ()
 (let* ((entry (org-element-at-point))
 (heading (org-get-heading t t t t))
 (level (org-outline-level))
 (tags (org-get-tags))
 (todo (org-get-todo-state))
 (contents ""))
 (org-end-of-meta-data nil)
 (when (eq (org-element-type (org-element-at-point)) 'paragraph)
 (let ((start (point)))
 (org-next-visible-heading 1)
 (setq contents (buffer-substring-no-properties start (point)))
 (dolist (pattern '("^#\\+begin.*" "^#\\+end.*" "\n+"))
 (setq contents (replace-regexp-in-string pattern
 (if (string= pattern "\n+") " " "")
 (string-trim contents))))))
 (setq max-level (max max-level level))
 (push (list (concat (make-string (* (1- level) 2) 45) " " heading)
 (or todo "") (string-join tags ":") (or contents "")) rows))))
 (setq rows (reverse rows))
 (push 'hline rows)
 (cons header rows))

How It Works

org-map-entries: This function iterates through all headings in the Org document. Each heading that it encounters produces metadata, such as the heading title, level in the hierarchy, TODO state, tags, and the content following the heading.
Content Sanitization: For headings with associated content, newline characters and code block markers (like #+begin_src and #+end_src) are removed. This ensures that the content is condensed into a single line for insertion into the Org table.
heading: This variable stores the full heading, formatted with indentations based on its nesting level (level) to visually represent its position in the Org structure.
Output Format: The information is collected into a list (rows). The list contains individual lists representing rows of the table. A “horizontal line” ('hline) is inserted to act as a row separator.
Finally, the first list in rows is a header row (header), which includes the column titles: “Title”, “TODO”, “Tags”, and “Contents”.

When evaluated (C-c C-c) within this org source for the blog post the code block outputs a table like the one below, note that it will also include the example Org Structure defined in the next section.

Example Org Structure

Here’s an example Org structure that would produce part of the table above:

** TODO one :tag1:tag2:
*** DOING sub

content 1

#+begin_src
>>
code start
more code >>
#+end_src
after code

**** further into the tree! :subtag:

first line, no space before!

***** even further down the hole! :hole_tag:

No escape!!

** TODO two :tag_two:

content 2

** three
SCHEDULED: <2024-11-10 Sun>

Exporting the Table

Once this table is generated, it will correctly render within Org mode, respecting the Org table formatting rules. You can also export it to other formats (like HTML or Markdown) using standard Org export commands (such as C-c C-e h or C-c C-e m).

For example, exporting to HTML will produce a structured HTML table with the column headers formatted as table header (<th>) elements, and the data rows and horizontal lines correctly converted into formatting tags.

Conclusion

By leveraging Emacs Lisp and Org Babel, we’ve created a highly flexible way to extract information from Org headings and output it as a well-structured table. This method not only saves time when working with large or hierarchical documents, but it also provides a powerful way to export Org-based data to various formats based on your needs.

This approach can be extended further to include other metadata (like scheduled dates, deadlines, or custom properties) or more advanced formatting options for both Org and export formats.

Next Steps: Experiment with Org Babel to explore even more advanced use cases, for example I would like to format the table in a more flexible manner, for example to specify the width and maybe the cell / row colour based on content.

Generate Current Year tag in an Org Capture Template

James Dyer — Fri, 01 Nov 2024 08:30:00 +0000

A crucial aspect of maintaining organized and up-to-date notes is the use of Org Capture templates.

I have currently always hard-coded/set the current year in my org capture templates for use when exporting/constructing my web pages and as a tag for some filtering / web index generation. Of course the main disadvantage of this is that I have to remember to update the year each year, of which I often fail miserably. ☹️

Can I get an org capture template to auto generate just the year as a tag like other capture template attributes?

Well yes, yes you can, and there a couple of ways to achieve this.

Firstly there is the org capture family of format strings which inserts a date when the capture is triggered. This is a bit much for me and instead of generating just a string for the year, each specifier will generate a full timestamp:

%U — Inactive Timestamp (Full Date and Time)
%T — Active Timestamp (Full Date and Time)
%t — Active Timestamp (Current Date Only)
%u — Inactive Timestamp (Current Date Only)

However there is another format specifier, which can just insert the year, simply use %<%Y> which is part of a pretty standard common date or time string format options, for example, here are some useful format specifiers that can be used:

`%Y`: Year (e.g., `2023`)
`%m`: Month (e.g., `10` for October)
`%d`: Day (e.g., `05`)
`%H`: Hour (24-hour clock)
`%M`: Minute
`%S`: Seconds
`%A`: Full weekday name (e.g., `Monday`)
`%B`: Full month name (e.g., `October`)

Well that was easy, so to insert a year tag I can just wrap colons around %<%Y>

Just for fun, lets try something a little more advanced to achieve the same goal but this time allowing much more flexibility.

A particularly useful functional aspect of an org template is that the dynamic generation of the current year can be achieved using some elisp. Lets use the (format-time-string) function.

Understanding `(format-time-string "%Y")`

Before diving into the implementation, let’s break down what (format-time-string "%Y") does:

format-time-string: This is an Emacs Lisp function that formats the current time and date into a string based on a specified format.
"%Y": This format code specifically fetches the four-digit representation of the current year. For example, in 2023, it would insert “2023”, and conforms to the date specifiers defined above for the more simple capture template format definition.

By embedding this function into my Org Capture templates, the inclusion of the current year is neatly automated, this not only reduces manual updates but also ensures consistency across my entries.

Implementing Dynamic Year in Capture Templates

Here’s an example Org Capture template that uses (format-time-string "%Y") to dynamically manage the year for Emacs-related entries:

("e" "Emacs" plain
 (file+function
 "~/DCIM/content/emacs--all.org"
 my-capture-top-level)
 "* TODO %^{title} :emacs:%(format-time-string \"%Y\"):"
 :PROPERTIES:
 :EXPORT_FILE_NAME: %<%Y%m%d%H%M%S>-emacs--%\\1
 :EXPORT_HUGO_SECTION: emacs
 :EXPORT_HUGO_LASTMOD: <%<%Y-%m-%d %H:%M>>
 :EXPORT_HUGO_CUSTOM_FRONT_MATTER+: :thumbnail /emacs/%<%Y%m%d%H%M%S>-emacs--%\\1.jpg
 :END:
 %?
 " :prepend t :jump-to-captured t)

Key Features of this Template

Automatic Year Insertion:
- The directive :%(format-time-string \"%Y\"):, within the headline, ensures that the current year is automatically included as a tag whenever you create a new entry. This functionality is particularly useful for organizing tasks by year, making it easier to retrieve and filter information based on time.
Enhanced Organization:
- By integrating the current year automatically, you maintain a systematic arrangement of notes and tasks, minimizing the need for manual adjustments every new year.
Ease of Use:
- This template is set up for simplicity and re-usability. Once implemented, it requires no further changes for year-specific adjustments, allowing you to focus on content generation rather than template management.

Benefits of Dynamic Year Management

Time-Saving: No need to modify the template annually, thus saving valuable time.
Consistent Records: Automatic year tagging provides a consistent way of tracking entries over time.
Improved Searchability: Facilitates year-based searches and statistics generation, enhancing the utility of your Org files.

selected-window-accent-mode with window colour blending options

James Dyer — Tue, 22 Oct 2024 08:40:00 +0100

I have enhanced selected-window-accent functionality with blending options to blend colourize the selected window (see below):

This means that not only will the mode-line, fringes and header be accent coloured, but also the whole selected window background colour, tinted to the alpha chosen.

The features added are as follows:

Introduced selected-window-accent-use-blend-background and selected-window-accent-use-blend-alpha to allow blending of the accent colour with the background of the selected window a selected alpha amount.
Introduced new toggle functions and added to transient:
- selected-window-accent-toggle-blend-background
- selected-window-accent-toggle-pywal
Added function selected-window-accent-blend-colors to support blending of two colours.
Updated selected-window-accent--set-foreground-color and selected-window-accent functions to incorporate new blending feature.
Improved existing functions for setting and toggling accent features, ensuring consistent style and formatting.
Cleaned up indentation and formatting inconsistencies across the file for better readability.

Example use of new selected window blending functionality:

(use-package selected-window-accent-mode
 :config (selected-window-accent-mode 1)
 :custom
 (selected-window-accent-fringe-thickness 10)
 (selected-window-accent-use-blend-background t)
 (selected-window-accent-use-blend-alpha 0.2)
 (selected-window-accent-tab-accent t)
 (selected-window-accent-custom-color "cyan4")
 (selected-window-accent-mode-style 'default))

(use-package selected-window-accent-mode
 :config (selected-window-accent-mode 1)
 :custom
 (selected-window-accent-fringe-thickness 10)
 (selected-window-accent-use-blend-background t)
 (selected-window-accent-use-blend-alpha 0.1)
 (selected-window-accent-tab-accent t)
 (selected-window-accent-custom-color "orange")
 (selected-window-accent-mode-style 'subtle))

Transforming Dired File Paths into Org Links

James Dyer — Thu, 17 Oct 2024 15:36:00 +0100

I am of course using org mode for organizing my tasks, notes and other paraphernalia.

In addition, I generate static web pages from org using hugo, with each org heading representing a single post.

I often find myself needing to refer to files stored in a directory, especially image files that can be org embedded and then passed through to Hugo by the ox-hugo package.

Navigating to the file and manually generating the appropriate org link can be just a little cumbersome - to initially pick up the file name and then insert the relevant org attributes.

dired-copy-filename-as-kill is a function I often use in dired, which copies the filename under point. I can then use something like tempel to insert the attributes. However, while the combination of copying the filename in dired and then remembering the tempel shortcode is quite efficient, I think this could be accomplished more cleanly with some Elisp and a dired-mode mapping.

Here is a typical embedded image form, which restricts the image within the org document to 300 pixels and to 100% width when exported through hugo to my web site.

#+attr_org: :width 300px
#+attr_html: :width 100%
[[file:static/emacs/20240918111443-emacs--Transforming-Dired-File-Paths-into-Org-Links-with-Emacs-Lisp.jpg]]

Lets walk through a custom function, my/dired-file-to-org-link, which transforms the dired file path under cursor/point into an org link and copies it to the kill ring for easy pasting.

(defun my/dired-file-to-org-link ()
 "Transform the file path under the cursor in Dired to an Org mode
link and copy to kill ring."
 (interactive)
 (let ((file-path (dired-get-file-for-visit)))
 (if file-path
 (let* ((relative-path (file-relative-name file-path
 (project-root (project-current t))))
 (org-link (concat "#+attr_org: :width 300px\n"
 "#+attr_html: :width 100%\n"
 "file:" relative-path "\n")))
 (kill-new org-link)
 (message "Copied to kill ring: %s" org-link))
 (message "No file under the cursor"))))

When my/dired-file-to-org-link is called in a dired buffer, it gets the file path under the point, transforms it into an Org link with specific attributes, and copies the link to the kill ring. This enables you to quickly paste it into your Org file.

I map this to the letter b in the dired-mode mapping, which for me mnemonically refers to (b)log and the b key is not one I currently use in dired.

Note also the use of project.el with the project functions, as I have a project top level defined for my website content, allowing for an easily generated relative path name.

Therefore for example, 20240918111443-emacs--Transforming-Dired-File-Paths-into-Org-Links-with-Emacs-Lisp.jpg from dired in an emacs directory is transformed into :

#+attr_org: :width 300px
#+attr_html: :width 100%
[[file:static/emacs/20240918111443-emacs--Transforming-Dired-File-Paths-into-Org-Links-with-Emacs-Lisp.jpg]]

Simple Directory and File Creation Using Vertico Completion Exit With Input

James Dyer — Wed, 09 Oct 2024 20:30:00 +0100

In my previous post about creating simple functions to create a new directory and file in dired, I received an interesting comment suggesting another way to bypass the potential messiness of completion and pass through the literal text input.

My last post :

Simple Directory and File Creation in Dired

It is a subtlety of most if not all completion systems, and that is to exit with any input, hence exiting without having to necessarily match and complete.

Given this, and given that I’m using the completion framework of vertico, I thought I would revisit the vertico github manual : https://github.com/minad/vertico

and I find :

M-RET -> vertico-exit-input

vertico-exit-input exits with the minibuffer input instead. Exiting with the current input is needed when you want to create a new buffer or a new file with find-file or switch-to-buffer. As an alternative to pressing M-RET, move the selection up to the input prompt by pressing the up arrow key and then press RET.

Well this is exactly the issue I was having and why I wrote my two little simple functions. Now if I build in M-RET into my muscle memory (which already seems pretty natural), I can refine my Emacs init, while adhering more to vanilla Emacs concepts. Also as I now am being more idiomatic, I suspect the M-RET keybinding may just come in handy at some point in the future.

So, now rebinding dired-mode-map as follows:

("_" . dired-create-empty-file)

This is all that is required; note that dired-create-directory is already bound to my preferred keybinding.

So continues the evolution of my Emacs understanding!

As a side-ish note, I have found that writing this blog provides not only an opportunity to explore a topic further and thoroughly understand it, thereby enabling me to articulate the subject fully, but also to receive comments and discover subtle nuances that I hadn’t realized existed or hadn’t thought to explore!

Syncing Tab Theme After Theme Load

James Dyer — Tue, 01 Oct 2024 09:50:00 +0100

Previously I wrote about the incompatibility of some Emacs themes with the tab-bar and my temporary fix:

Syncing Tab Bar To Theme

The tab bar was introduced in Emacs 27.1, during which I created a function to apply some simple logic to make the tabs look moderately decent and fit in with the new theme. The only thing I couldn’t figure out was how to activate the function after a theme load, as there didn’t seem to be a hook.

Well, actually there does seem to be such a hook and it seems to have gone into Emacs 29. As with a lot of these little tweaks I found this on reddit in the emacs subreddit:

https://www.reddit.com/r/emacs/comments/1ft3wwm/did_the_much_needed_theme_change_hook_arrive_with/

From my previous post I wrote :

Now that the defun is available, how to activate it? My first thought was to add a hook for when a theme is loaded, but there doesn’t seem to be such a feature!? I also tried advising around `load-theme`, but that didn’t go well either, it worked for themes that were not loaded, but for those that were, a change in state was not detected, and the tab theme tweak was not applied.

The solution is to simply add the following to your init file. Now that I know about this, I might even find some other use for it.

(defun my/after-theme-loaded(theme)
 (my/sync-tab-bar-to-theme))

(add-hook 'enable-theme-functions 'my/after-theme-loaded)

with the original my/sync-tab-bar-to-theme as follows:

(defun my/sync-tab-bar-to-theme ()
 "Synchronize tab-bar faces with the current theme."
 (interactive)
 (let ((default-bg (face-background 'default))
 (default-fg (face-foreground 'default))
 (inactive-fg (face-foreground 'mode-line-inactive))) ;; Fallback to mode-line-inactive
 (custom-set-faces
 `(tab-bar ((t (:inherit default :background ,default-bg :foreground ,default-fg))))
 `(tab-bar-tab ((t (:inherit default :background ,default-fg :foreground ,default-bg))))
 `(tab-bar-tab-inactive ((t (:inherit default :background ,default-bg :foreground ,inactive-fg)))))))

My tab theme fix is now activated on every theme load, and I no longer have to rely on muscle memory to make Emacs look colour-coherent when changing themes, which I do a lot!! 😀

Simple Directory and File Creation in Dired

James Dyer — Tue, 24 Sep 2024 20:00:00 +0100

Today I’ll simply delve into two custom functions that I’ve had in my init file for quite some time, my/dired-create-directory and my/dired-create-empty-file

I use them frequently enough that I thought they were worth mentioning and they augment my dired workflow when mapped to dired-mode-map keybindings.

For many years I would create a new file or folder in one of two ways, through the command line, or a GUI file explorer (with either a click in or bound F2 to edit the name), Emacs comes with it’s own directory manager so why not augment it with these features?

What about find-file I hear you say?, just press C-x C-f. This will prompt for a filename using the current directory of the current buffer and if you type a unique name it will create the file for you. Unfortunately though this will not always work in a simple predictable manner when the minibuffer completion mechanism kicks in.

my/dired-create-directory

This custom function simplifies creating a new directory by prompting for a name in the minibuffer, bypassing the default completion mechanism to avoid unwanted name suggestions.

(defun my/dired-create-directory ()
 "Wrapper to dired-create-directory to avoid minibuffer completion."
 (interactive)
 (let ((search-term
 (read-from-minibuffer "Dir : ")))
 (dired-create-directory search-term)))

Purpose: This function is a wrapper around the dired-create-directory function, designed to avoid the potential confusion of minibuffer completion and directly ask for the directory name.
Usage: When invoked, it prompts the user to input a directory name and creates it using the dired-create-directory function.

my/dired-create-empty-file

Similarly, this custom function facilitates the creation of an empty file by asking for the filename in the minibuffer without the default completion.

(defun my/dired-create-empty-file ()
 "Wrapper to dired-create-empty-file to avoid minibuffer completion."
 (interactive)
 (let ((search-term
 (read-from-minibuffer "File : ")))
 (dired-create-empty-file search-term)))

Purpose: This function wraps around dired-create-empty-file, providing a straightforward prompt for creating a new file.
Usage: When triggered, it asks the user to input a file name and then creates an empty file with that name.

These functions are bound to dired-mode-map as follows:

_: Create an empty file using my/dired-create-empty-file
+: Create a new directory using my/dired-create-directory

This gives me a good ergonomic LShift+<Right hand of number row> combination and is therefore not too taxing on the hands and each key command are just next to each-other to emphasize their similar nature.

In addition the dired mode map keybinding for creating a new directory is bound to + so there is consistency there too.

I suspect there are probably many other ways to achieve this functionality in Emacs, in this case I am specifically relying on dired function calls here but there is also the make-directory function and the shell-command for example if you want to drop in to using the operating systems tool set.

Adding Disk Usage Reporting to Emacs Dired

James Dyer — Wed, 18 Sep 2024 09:30:00 +0100

Just a quick one today. One of the great strengths of Emacs is its extensibility, I have mentioned before in adding the ability to disk report on the size of a directory in dired but I thought I would quickly revisit the topic, demonstrating the function I currently use.

This functionality will allow you to run disk usage reports directly within Dired, using the du -hc command. This will make it easier to figure out how much space directories are taking up.

The aim of this function is to run the Linux command du -hc on the directory currently under the cursor in Dired mode. The command du -hc provides a human-readable summary of disk usage for the specified directory.

Here’s the function that accomplishes this task:

(defun my/dired-du ()
 "Run 'du -hc' on the directory under the cursor in Dired."
 (interactive)
 (let ((current-dir (dired-get-file-for-visit)))
 (if (file-directory-p current-dir)
 (dired-do-async-shell-command "du -hc" nil (list current-dir))
 (message "The current point is not a directory."))))

and that is it!

New Package arscript-mode

James Dyer — Sat, 07 Sep 2024 08:55:00 +0100

As an avid ArtRage user for almost 10 years I have in the past delved into the subtle art of editing arscript files:

ArtRage arscript files are specialized script files used by the ArtRage painting software to automate and record various painting actions and effects. These files encapsulate sequences of drawing commands, tool selections, color settings, and other actions that can be replayed to recreate the painting process. The arscript format includes structured elements such as keywords, modifiers, structured tags, and numerical values, allowing for detailed specification of both high-level actions and granular details like brush strokes and layer manipulations. The format aims to facilitate complex artistic workflows by enabling repeatable and shareable painting routines, making it an essential tool for digital artists using ArtRage.

They are designed to me modifiable, so what better way to modify them than with Emacs!

I created an arscript major mode with the idea to eventually add text manipulation functions to tweak a painting playback.

Summary

arscript-mode is an Emacs major mode designed to facilitate the editing of arscript files, providing syntax highlighting and other useful editing features tailored specifically for the arscript file format.

Screenshot

Links

https://www.artrage.com

https://www.artrage.com/manuals/scripts/

https://www.artrage.com/manuals/scripts/script-editing-tips/artrage-scripting-guide/

Whats New

v0.1.0

First version

Features

Syntax highlighting for arscript-specific keywords, modifiers, and structures.
Custom indentation logic for arscript code blocks.
Auto-detection of .arscript files to automatically enable the mode.

Installation

use-package (MELPA)

(use-package arscript-mode)

use-package (emacs 30+) directly from github

Put the following into your emacs init file:

(use-package arscript-mode
 :vc (:fetcher github :repo "captainflasmr/arscript-mode"))

From source

Download the `.el` file and place it in your Emacs `load-path` or in a specific source directory “~/source/repos/arscript-mode”

Then either manually load it or add it to your configuration to be loaded at startup.

(require 'arscript-mode)

(use-package arscript-mode
 :load-path "~/source/repos/arscript-mode")

Usage

Opening any .arscript file with Emacs should automatically enable arscript-mode, providing you with syntax highlighting and indentation support for editing arscript files.

Example arscript file:

//===========================================================================
//===========================================================================
// ArtRage Script File.
//===========================================================================
//===========================================================================
//===========================================================================
// Version Block - Script version and ArtRage version:
//===========================================================================
<Version>
ArtRage Version: ArtRage 3 4
ArtRage Build: 4.5.3
Professional Edition: Yes
Script Version: 1
</Version>
//===========================================================================
// Header block - Info about the painting/person who generated this script:
//===========================================================================
<Header>
// === Project data
Painting Name: "Willow"
Painting Width: 2456
Painting Height: 2206
Painting DPI: 200
Mask Edge Map Width: 1280
Mask Edge Map Height: 800
// === Author data
Author Name: ""
Script Name: ""
Comment: ""
Script Type: ""
Script Feature Flags: 0x000000034
</Header>
//===========================================================================
// ArtRage project features. Sets the startup state of the script:
//===========================================================================
<StartupFeatures>
Script Startup Features: {
}// End of Script startup feature binary data.
</StartupFeatures>
//===========================================================================
// Script data follows:
//===========================================================================
<Events>
Wait: 0.000s EvType: Command CommandID: CID_SetClearCanvas ParamType: flag Value: { true }
Wait: 14.031s EvType: Command CommandID: LoadReferenceImage Idx: 0 Reference Image: {
}// End of reference image binary data.
Wait: 2.694s EvType: Command CommandID: ReferenceImageXForm Idx: 0 Loc: (0.182031, 0.2) Size: (320, 236) Scale: 1 Rot: 0 Off: (0, 0)
Wait: 0.682s EvType: Command CommandID: ReferenceImageXForm Idx: 0 Loc: (0.179688, 0.45) Size: (320, 236) Scale: 1 Rot: 0 Off: (0, 0)
Wait: 2.298s EvType: Command CommandID: ReferenceImageXForm Idx: 0 Loc: (0.180078, 0.45) Size: (803, 600) Scale: 1 Rot: 0 Off: (0, 0)
Wait: 2.678s EvType: Command CommandID: ReferenceImageXForm Idx: 0 Loc: (0.279297, 0.395) Size: (803, 600) Scale: 1 Rot: 0 Off: (0, 0)
Wait: 7.316s EvType: Command CommandID: ReferenceImageXForm Idx: 0 Loc: (0.278906, 0.395) Size: (864, 646) Scale: 1 Rot: 0 Off: (0, 0)
Wait: 12.245s EvType: Command CommandID: ReferenceImageXForm Idx: 0 Loc: (0.278906, 0.395) Size: (139, 100) Scale: 1 Rot: 0 Off: (0, 0)
Wait: 0.000s EvType: Command CommandID: SetForeColour ParamType: Pixel Value: { 0x0FF7386A0 }
Wait: 3.341s EvType: Command CommandID: CID_SetClearCanvas ParamType: flag Value: { true }
Wait: 3.819s EvType: Command CommandID: ReferenceImageXForm Idx: 0 Loc: (0.278906, 0.395) Size: (684, 520) Scale: 1 Rot: 0 Off: (0, 0)
Wait: 8.354s EvType: Command CommandID: ReferenceImageXForm Idx: 0 Loc: (0.278906, 0.395) Size: (161, 119) Scale: 1 Rot: 0 Off: (0, 0)
Wait: 1.659s EvType: Command CommandID: CanvasXForm Scale: 0.0840503 Rot: 0 Off: (537, 307)
Wait: 1.123s EvType: Command CommandID: CanvasXForm Scale: 0.0840503 Rot: 0 Off: (497, 259)
<StrokeEvent>
<StrokeHeader>
<EventPt> Wait: 1.116s Loc: (1054.6, 527.3) Pr: 0.0521997 Ti: 0.489467 Ro: 1.27568 Fw: 1 Bt: 0 Rv: NO Iv: NO </EventPt>
<Recorded> Yes </Recorded>
<RandSeed> 0x000000000, 0x000000000 </RandSeed>
<Smooth> Count: 3
Loc: (1054.6, 527.3) Pr: 0.132196 Ti: 1 Ro: 0 Fw: 1 Bt: 0
Loc: (1086.56, 527.3) Pr: 0.132196 Ti: 1 Ro: 0 Fw: 1 Bt: 0
Loc: (1102.54, 527.3) Pr: 0.132196 Ti: 1 Ro: 0 Fw: 1 Bt: 0
</Smooth>
<PrevA> Loc: (-679.912, 774.652) Pr: 0.135925 Ti: 1 Ro: 0 Fw: 1 Bt: 0 </PrevA>
<PrevB> Loc: (-505.365, 600.105) Pr: 0.174106 Ti: 1 Ro: 0 Fw: 1 Bt: 0 </PrevB>
<OldHd> Loc: (1086.56, 527.3) Pr: 0 Ti: 0.477897 Ro: 1.27511 Fw: 1 Bt: 0 Dr: (-0.919609, -0.392834) Hd: (0.392834, -0.919609) </OldHd>
<NewHd> Loc: (1054.6, 527.3) Pr: 0 Ti: 0.489467 Ro: 1.27568 Fw: 1 Bt: 0 Dr: (-0.99682, -0.0796825) Hd: (0.0796825, -0.99682) </NewHd>
</StrokeHeader>
Wait: 0.000s Loc: (1054.6, 535.29) Pr: 0.0569451 Ti: 0.489467 Ro: 1.27568 Fw: 1 Bt: 0 Rv: NO Iv: NO
Wait: 0.002s Loc: (1054.6, 543.279) Pr: 0.0237271 Ti: 0.489467 Ro: 1.27568 Fw: 1 Bt: 0 Rv: NO Iv: NO
</StrokeEvent>

Customization

Currently, arscript-mode provides a basic set of features optimized for general usage. Future versions may include customizable options based on user feedback.

Contributing

Contributions to arscript-mode are welcome! Whether it’s bug reports, feature suggestions, or code contributions, feel free to reach out or submit pull requests on GitHub.

ROADMAP

TODO review syntactical keyword highlighting based on contents of arscript pdf manual

TODO add text transformation functions to affect arscript and hence ArtRage playback

Alternatives

As far as I can tell this is the first Emacs major mode supporting the arscript format.

Streamlining eshell with popper, capf-autosuggest, and Enhanced Autocompletion

James Dyer — Fri, 30 Aug 2024 11:20:00 +0100

In this post, I will describe the small enhancements and tweaks I have applied to eshell to make it feel more like a typical linux terminal using the fish shell and especially the inline autosuggestion feature that fish has out-of-the-box.

For clarity, the autosuggestions in fish enable autocompletion suggestion previews as you type, for example :

Fish will suggest a single command to the right of the cursor dynamically in grey, its just like the terminal built-in readline C-r/C-s, but inline and for your most recent command based on the text input. As a bonus of course, fish will have readline built in and therefore a familiar Emacs keybinding C-e will complete the suggested completion for you!

Over the years, I have progressed through possibly all the terminal shells, from csh and ksh through to bash and zsh, and now I use fish. Similarly to the popularity of more native-based light-weight Emacs plugins, such as vertico, corfu, and cape, the fish shell is lightweight and targets important functions right out of the box.

For years, I relied on readline shell functionality, with the keybinding C-r bringing up a command history which I could navigate. It is much like vertico, and although efficient, I now prefer the fish method of inline completion autosuggestion preview as I feel I can get to my desired commands faster.

With eshell, there is the native completion TAB based system but it is clunky, so lets see how we can make it more fishy! 😀 🐠

Inline Fish-like autosuggestion

I’m going to dive straight in to enabling inline autosuggest preview for eshell to emulate Fish-like inline completion as described earlier. I use a package called capf-autosuggest:

(use-package capf-autosuggest
 :hook
 (eshell-mode . capf-autosuggest-mode))

There are other similar packages out there, but so far I have found this to be the best and seems to work out-of-the-box. It is shell (comint) based, so it won’t work anywhere else in Emacs, but that is fine for me as I have plenty of other completion mechanisms to choose from.

Of course you will need to have an eshell history to use effectively, but it will also autosuggest commands found on your PATH.

Note : that as of Emacs 30 there is a new function - completion-preview-mode which looks as though it does something similar to capf-autosuggest but for all buffers!

This mode automatically shows and updates the completion preview according to the text around point.

I haven’t tested this fully yet but when Emacs 30 comes out I will probably have a closer look.

Creating Custom eshell Buffers

There are other eshell tweaks I make to generally improve my workflow and I will now describe how I create eshell buffers. Below is a function that allows the creation of eshell buffers with defined names, making it easier to manage multiple shell sessions.

(defun my/shell-create (name)
 "Create a custom-named eshell buffer with NAME."
 (interactive "sName: ")
 (eshell 'new)
 (let ((new-buffer-name (concat "*eshell-" name "*")))
 (rename-buffer new-buffer-name t)))

(global-set-key (kbd "M-o s") #'my/shell-create)

The reason for this is that I gain greater control over eshell buffer naming, which makes using tools like Popper (see below) and creating multiple eshells simpler. For example, opening an initial eshell in Emacs is easy, just run eshell, however, to create another unique eshell, you must remember to pass in a universal argument (which I always forget); otherwise, you will just switch to the existing eshell. So this function will always create a new shell, I can always switch between eshell buffers as normal through Emacs anyway.

Toggling eshell with Popper

Popper provides a pop-up window manager, making it easy to toggle eshell in and out of view. It has been a recent discovery, but now I can’t live without it.

(use-package popper
 :init
 (setq popper-reference-buffers
 '("\\*eshell.*"
 flymake-diagnostics-buffer-mode
 help-mode
 compilation-mode))
 (popper-mode 1)
 (popper-echo-mode 1)
 :custom
 (popper-window-height 15))

(bind-key* (kbd "C-;") #'popper-toggle)

Since I control my eshell naming, I can set up Popper with the requisite regex to pop up eshell when it is opened or created.

What I like about Popper is that it does what it says: it pops windows in and out. I also like to pop Flymake, Help, and Compilation windows, this keeps Emacs clean and uncluttered, and if, for example, I build something, if I need a terminal, or need some linting diagnostics, I can just quickly pop in and out and switch between each pop.

As a note, if more than one window has been “poppered” then switching between each “pop” is easy through a keybinding M-<number>, which is something I also use all the time.

General eshell Configuration

Here is my general eshell setup. I don’t think there is anything controversial here, but as you can see, I have enabled a hook to my own shell setup function, and yes, I know I could add capf-autosuggest-mode to this, but for clarity in this post, I kept it specifically in the capf-autosuggest section.

(use-package eshell
 :config
 (setq eshell-scroll-to-bottom-on-input t)
 (setq-local tab-always-indent 'complete)
 (setq eshell-history-size 10000)
 (setq eshell-save-history-on-exit t) ;; Enable history saving on exit
 (setq eshell-hist-ignoredups t) ;; Ignore duplicates
 :hook
 (eshell-mode . my/eshell-hook))

Yes, I know, the history size is ridiculous! (default is 128) but why not build up a huge collection of my past commands for a more robust autosuggest mechanism?!

eshell completion using consult

What about other completion mechanisms?, for example emulating the C-r/C-s readline functionality?

For a while I used consult to bring up a completing-read searchable eshell history via consult-history, and although it does work well I found I wasn’t really using it. However, I do still have it enabled:

(define-key eshell-hist-mode-map (kbd "M-r") #'consult-history))

UI completion with Corfu and Cape

Now for some completion UI setup to augment the capf-autosuggest functionality - we are in Emacs after all!

In this case I am choosing to use corfu but company is another option. The idea here is to bring up a typical corfu completion popup UI when typing, for example:

Here you can see it working along-side capf-autosuggest

Here is the config:

(use-package cape)

(defun my/eshell-hook ()
 "Set up eshell hook for completions."
 (interactive)
 (setq-local completion-styles '(basic partial-completion))
 (setq-local corfu-auto t)
 (corfu-mode)
 (setq-local completion-at-point-functions
 (list (cape-capf-super
 #'pcomplete-completions-at-point
 #'cape-history)))
 (define-key eshell-hist-mode-map (kbd "M-r") #'consult-history))

I decided to have a simple set of completion styles, none of those fancy fuzzy, orderless, flex shenanigans as I can generally string a few characters of the command I want to use to quickly generate a suitable matching command.

cape at this point becomes useful as it exposes the function cape-history to corfu. Once set up, typing in eshell now brings up the completion popup and you would use as expected. This for me has now replaced consult-history as it feels more integrated and faster for my workflow while producing the same functionality.

Note: I have explicitly turned on corfu autocompletion as in general I like to have it turned off. I have learnt that things can get tricky and laggy with autocompletion turned on when using eglot and communicating over an LSP, so I prefer to bind to a key and call the UI on demand. Also I’m a little old school in that I don’t like a busy work window, I’m not used to seeing a dynamic autocompletion appear when I am coding and would rather manually leverage this functionality when required.

Combining all of it!

The corfu functionality described above can run nicely along-side capf-autosuggest. For some, this may seem cluttered and you may want to choose one or the other, but for me, for the moment, this suits my workflow.

Conclusion

By integrating popper, capf-autosuggest, corfu, and cape into my eshell setup, I think I may have finally been able to almost completely fully transition terminal usage to emacs through eshell.

In addition, if I am running Emacs on a system that doesn’t have the fish shell available, for example windows, or a restricted linux development environment, then eshell can now increase my efficiency on the command line.

Syncing Tab Bar To Theme

James Dyer — Sat, 24 Aug 2024 11:00:00 +0100

Using tabs as part of my workflow has enabled a nice encapsulation and collection of files per tab that I can quickly switch to.

An issue I consistently run into however is tab theming. I’m a constant theme switcher, not just in Emacs but also operating system wide, and I often switch wallpapers.

Unfortunately, with the advent of tabs in version 27.1, many Emacs themes lack styles for the new tab faces, resulting in a wonky disjointed appearance.

For example:

Elisp can come to the rescue again of course, this is my attempt at making the tabs fit in a little better with an incompatible theme:

(defun my/sync-tab-bar-to-theme ()
 "Synchronize tab-bar faces with the current theme."
 (interactive)
 (let ((default-bg (face-background 'default))
 (default-fg (face-foreground 'default))
 (inactive-fg (face-foreground 'mode-line-inactive)))
 (custom-set-faces
 `(tab-bar ((t (:inherit default :background ,default-bg :foreground ,default-fg))))
 `(tab-bar-tab ((t (:inherit default :background ,default-fg :foreground ,default-bg))))
 `(tab-bar-tab-inactive ((t (:inherit default :background ,default-bg :foreground ,inactive-fg)))))))

which does its best to fit tab themes to the loaded theme, to give something like:

There is a bit of logic here, but essentially, for the whole tab-bar theming, I just pick up the foreground and background faces defined in the theme and for the selected tab tab-bar-tab, the default theme foreground switches to ensure the selected tab will always stand out.

For inactive tabs, I set the foreground to that used in the mode-line-inactive.

Now that the defun is available, how to activate it? My first thought was to add a hook for when a theme is loaded, but there doesn’t seem to be such a feature!? I also tried advising around `load-theme`, but that didn’t go well either, it worked for themes that were not loaded, but for those that were, a change in state was not detected, and the tab theme tweak was not applied.

My current solution is simply to make the function interactive and build up some muscle memory to run it every time I switch themes and the tab theming looks wonky. I guess I could wrap around load-theme with my own theme loading function, then activate my/sync-tab-bar-to-theme afterwards, but I would rather keep the default theme selection function and run this function later.

P.S I also have a little idea to perhaps add this functionality to selected-window-accent-mode as this is related to clearly defining a selected element in Emacs.

Integrate Pywal Colors into Selected-Window-Accent-Mode for Wallpaper Accent Matching in Emacs

James Dyer — Fri, 16 Aug 2024 20:49:00 +0100

I have updated my emacs package selected-window-accent-mode

The Selected Window Accent Mode is an Emacs package designed to visually distinguish the currently selected window by applying a unique accent color to its fringes, mode line, header line, and margins.

v0.9.0 <2024-08-10 Sat>

Added Pywal color integration to selected-window-accent-mode to allow the accent color to be consistent with the wallpaper of the operating system.

Pywal is a tool on linux that generates color schemes from images, allowing users to apply these colors to their desktop and application themes for a cohesive and dynamic look.

Note: will only work on linux.

Introduced `selected-window-accent-use-pywal` option to use a Pywal-generated color palette.
Update logic in `selected-window-accent` function to use Pywal color if enabled.
Require `json` package for handling Pywal palette.

Example use:

(setq selected-window-accent-use-pywal t)

When enabled, color1 is selected as the accent color, taken from the file : ~/.cache/wal/colors.json which is a generic color file typically generated by pywal.

This means that the accent color can be more tied in with the current wallpaper once pywal is connected to the wallpaper change mechanism of your operating system.

Note that this feature will require an external pywal generation step, triggered on wallpaper change, examples given below.

See below for an example colors.json file

Technically any tool that can write to a json file in a similar format will have a carry through affect on the accent color associated with this package. Here is an example :

{
"wallpaper": "/home/jdyer/.last_wallpaper.jpg",
"alpha": "100",
"special": {
"background": "#0d1a05",
"foreground": "#c8cfdb",
"cursor": "#c8cfdb"
},
"colors": {
"color0": "#0d1a05",
"color1": "#8FA944",
"color2": "#165E97",
"color3": "#5C7391",
"color4": "#748AA6",
"color5": "#7498C4",
"color6": "#8D9BB1",
"color7": "#c8cfdb",
"color8": "#8c9099",
"color9": "#8FA944",
"color10": "#165E97",
"color11": "#5C7391",
"color12": "#748AA6",
"color13": "#7498C4",
"color14": "#8D9BB1",
"color15": "#c8cfdb"
}
}

On linux, install python-pywal using your package manager of choice.

At which point you can generate a colors.json with the following commands:

wal -c
wal -i ~/.last_wallpaper.jpg -q -n

Wallpaper Change Example

Changing a wallpaper and hooking pywal up accordingly, which technically should work for both Wayland and X11.

#!/bin/bash

wallpaper_path="$(find ~/wallpaper-dir -type f | shuf -n 1)"
echo $wallpaper_path > ~/.last_wallpaper_path
cp -f $wallpaper_path ~/.last_wallpaper.jpg

if [[ $XDG_SESSION_TYPE == "x11" ]]; then
 feh --bg-scale "$wallpaper_path"
fi

if [[ $XDG_SESSION_TYPE == "wayland" ]]; then
 swww img "$wallpaper_path" --transition-step 20 --transition-fps=20
fi

# lets run pywal for colour scheme generation
wal -c
wal -i ~/.last_wallpaper.jpg -q -n

Ready Player Mode different Utilities for Video and Audio!

James Dyer — Sun, 11 Aug 2024 16:00:00 +0100

Regarding my previous post, you can now disregard my little Frankensteinian elisp effort!:

Ready Player Mode with a little elisp Tweak

Thanks to a quick turnaround from Author: Alvaro Ramirez https://xenodium.com URL: https://github.com/xenodium/ready-player Version: 0.4.1 now directly caters for the ability to use different utilities for video and audio, as thus:

(use-package ready-player
 :init
 (ready-player-mode 1)
 :custom
 (ready-player-thumbnail-max-pixel-height 200)
 (ready-player-autoplay nil)
 (ready-player-repeat t)
 (ready-player-shuffle t)
 (ready-player-open-playback-commands
 '((ready-player-is-audio-p "mplayer")
 (ready-player-is-video-p "mpv"))))

Really nice!! 😀

Ready Player Mode with a little elisp Tweak

James Dyer — Sat, 10 Aug 2024 09:42:00 +0100

I’m really enjoying ready-player at the moment, so much so I think it might end up replacing emms.

I listen to music in a very simple, almost old-fashioned way, album by album, and I have my music collection well organized, with each album in a separate directory and in a way, emms was a little too much.

ready-player is well integrated with dired, so opening an audio file, for example, will kickstart the listening process for me. I like to have shuffle on (ready-player-shuffle), and with ready-player-repeat if there is more media to play in the current directory then it will enter a continuous play mode.

Here are my current settings:

(use-package ready-player
 :init
 (ready-player-mode 1)
 :custom
 (ready-player-thumbnail-max-pixel-height 200)
 (ready-player-autoplay nil)
 (ready-player-repeat t)
 (ready-player-shuffle t)
 (ready-player-open-playback-commands
 '(
 ("mpv" "--audio-display=no")
 ("mplayer")
 ("ffplay")
 ("vlc")
 )))

The only little issue I have run into so far (and I encountered something similar with emms) is to figure out which media player back-end works best with my set-up, I am running SwayWM on Arch.

For some reason emms would only run well with vlc (found by trial and error). With ready-player the default mpv worked well in most cases except it wouldn’t automatically move on to the next audio track when ready-player-repeat was set.

I am happy with ready-player opening videos through mpv by default and would only really want to ever use mpv for video playback.

So first things first, lets establish which back-end gives me a continuous audio playback.

With a little trial and error (simply swapping around the back-ends) I found that mplayer was the one that worked for me, mplayer can play videos too but my muscle memory is so mpv-centric that I always want to be using mpv for video playback.

With ready-player as far as I can tell there is just a single list of potential playback commands which applies to all media types. ready-player is in its early stages of development so I wouldn’t be surprised if at some stage this might get added for more flexibility/customization. But for me it doesn’t really matter and in fact gives me the opportunity to flex my elisp know-how.

Can I write something to overcome this issue?

Emacs is essentially just an elisp machine anyway, so lets write some elisp to augment the current ready-player functionality to suit my multiple playback-end needs, here is some elisp:

(defun set-ready-player-commands ()
 "Set `ready-player-open-playback-commands` based on file extension."
 (let ((file-extension (file-name-extension (buffer-file-name))))
 (setq ready-player-open-playback-commands
 (cond
 ((member file-extension '("mp4" "mkv" "mov" "avi"))
 '(("mpv" "--audio-display=no")
 ("mplayer")
 ("ffplay")
 ("vlc")))
 ((equal file-extension "mp3")
 '(("mplayer")
 ("mpv" "--audio-display=no")
 ("ffplay")
 ("vlc")))
 (t
 '(("mpv" "--audio-display=no")
 ("vlc")
 ("ffplay")
 ("mplayer")))))))

(add-hook 'find-file-hook 'set-ready-player-commands)

Simply, I just added some extra ready-player setup whenever a buffer is loaded from a file, essentially when I select it from dired.

I set the playback commands based on the extension, so for a video file it can use mpv, for an mp3 it prefers mplayer, with a fallback for any other type of file. I guess I could have been a little more flexible in defining a wider range of audio file, but I generally only listen to mp3.

With that addressed, ready-player now seems to give me much less friction than emms, with emms I would have to perform roughly the following steps to even begin listening to a music album:

first initialise - add files so emms can load in metadata
browse to select music album
push to a playlist
jump to playlist to perform track functions

I would have to remember emms commands, or build up muscle memory, but with ready-player I just need to navigate to the relevant music folder using dired, open a file and I’m ready to go!, and the front-end is like any standard media player which makes more sense to me.

If I want to modify playback then I’m quite happy to jump to the playback buffer which can be accomplished quickly through vertico by fuzzy finding “ready”, or by pushing ready-player to its own tab.

I think I will continue to play around with this cool little package.

Efficient File Searching in Emacs: Leveraging completing-read with Customizable Methods

James Dyer — Sun, 04 Aug 2024 09:05:00 +0100

I thought I would share a little bit of elisp that I’ve been using for a while now that allows me to quickly find a file. It leverages completing-read, allows the selection of the find method and will search recursively.

When called you can select which search type you prefer:

You can select the built-in find-name-dired but as you see I can also choose an external find tool such as find, fd or rg and it should be flexible enough to add in any others by expanding find-options in the function below:

(defun my/find-file ()
 "Find file from current directory in many different ways."
 (interactive)
 (let* ((find-options '(("find -type f -printf \"$PWD/%p\\0\"" . :string)
 ("fd --absolute-path --type f -0" . :string)
 ("rg --follow --files --null" . :string)
 ("find-name-dired" . :command)))
 (selection (completing-read "Select : " find-options))
 (metadata '((category . file)))
 (file-list)
 (file))
 (pcase (alist-get selection find-options nil nil #'string=)
 (:command
 (call-interactively (intern selection)))
 (:string
 (setq file-list (split-string (shell-command-to-string selection) "\0" t))
 (setq file (completing-read (format "Find file in %s: " (abbreviate-file-name default-directory))
 (lambda (str pred action)
 (if (eq action 'metadata)
 `(metadata . ,metadata)
 (complete-with-action action file-list str pred)))
 nil t nil 'file-name-history)))
 (when file (find-file (expand-file-name file))))))

To be completely honest, I don’t really use Emacs’ built-in find functions, such as find-file and find-name-dired. Here are a few reasons why:

Speed and Efficiency
- Tools like fd and rg are incredibly fast and efficient.
- They allow easy filtering through a simple .ignore file configuration.

Enhanced File Search
- I can leverage completing-read to process the file list.
- Using vertico, I gain the advantage of fuzzy completion, making file search more efficient and user-friendly.

Alternative Methods
- I seldom need to find a single file using find-file
- Instead, I rely on bookmarks, dired and recentf

Dired Benefits
- While find-name-dired offers the benefits of a dired buffer, I generally don’t need to perform specific actions on files found this way.
- Most of the time, I just need to jump to a file quickly.
- A dired bufer can be generated through embark-export anyway when going through a file fuzzy search at any point.

Customization and Flexibility
- External tools often provide more customization options, which align better with my workflow.
- These tools integrate seamlessly with my Emacs setup, enhancing my overall productivity.

By considering these reasons, I’ve found that external tools better fit my workflow compared to the built-in Emacs find functions when wanting to find a file quickly.

P.S. I still have a fondness for the basic find command, which I continue to use, particularly on the command line and especially when operating through SSH. However, I still can’t remember how to prune directories!, but then who can? 😀

Sending Dired Directories to Meld for Directory Comparison

James Dyer — Sun, 28 Jul 2024 16:43:00 +0100

A common activity for a Software Engineer is to compare two directories, especially those that might require a level of merging. My preferred tool of choice in this instance is Meld

Meld is a visual diff and merge tool that is widely used for comparing files, directories, and version-controlled projects.

For Meld, the workflow is generally straightforward: simply open a file explorer alongside and drag and drop the required directories.

But what about comparing directories seamlessly as part of the Emacs ecosystem I hear you say? 🫢

Well, I am trying to incorporate ztree-diff into my workflow, but after a few minutes of grappling with it, I always reach for Meld as I know it well (yes, I know this isn’t really the Emacs way, in which an initial investment of blood, sweat and toil eventually reaps dividends). I will persist with ztree-diff, but for now, to at least get a more seamless directory comparison experience from within Emacs I will have to just fall back on the tried and tested method of invoking an external application, and in this case by sending directories marked in dired to Meld, here is some elisp:

(require 'cl-lib)

(defun my/dired-meld-diff-all-dwim ()
 "Compare all marked directories in all visible Dired buffers using Meld.
 The order of directories respects the order suggested by `dired-dwim-target`."
 (interactive)
 (let ((files ()))
 (dolist (window (window-list))
 (with-current-buffer (window-buffer window)
 (when (and (derived-mode-p 'dired-mode)
 (dired-get-marked-files))
 (setq files (append files (dired-get-marked-files))))))
 (if (or (<= (length files) 1)
 (not (cl-every 'file-directory-p files)))
 (message "Please mark at least two directories.")
 (apply 'start-process "meld" nil "meld" files))))

(define-key dired-mode-map (kbd "C-c m") 'my/dired-meld-diff-all-dwim)

*edit: <2024-07-29 Mon> every is now obsolete, replaced with cl-every

This method has the advantage of honouring dired-dwim-target through the (window-list) function which I am now pretty familiar with as I often use dired-do-copy and dired-do-rename

So how does this work?, well now I can split windows, bring up some dired buffers, mark directories to compare, and then make sure I am in the dired buffer that is to appear on the LHS of the Meld comparison before I then run the command. The destination directory would then be defined according to dired-dwim-target which I have set to t which is the next dired visible buffer in a clockwise direction, but can be adjusted as desired.

With a little experimentation I found out that (dired-get-marked-files) retrieves the dired item that the cursor is over, therefore each directory doesn’t necessary even need to be explicitly marked!, so you could just split with two dired buffers, leave the cursor over the destination directory, switch to the source dired buffer and leave the cursor over the source directory before running the command above.

More experimentation reveals that even three directories can be sent to Meld for comparison!, just open the dired buffers, hover cursor or mark, make sure they are visible, set up in the clockwise order and then focus the cursor on the source directory.

Is it a little weird that I’m talking about experimentation when this is a function I wrote myself? 😀 A three directory comparison is not something I have ever used but I deliberately left the function open and flexible enough and it doesn’t really do any harm…

Selected Window Accent Mode v0.8.0

James Dyer — Fri, 19 Jul 2024 11:15:00 +0100

Whats New

What’s New in Selected Window Accent Mode v0.8.0 - (selected-window-accent-mode) which is my window accent package in MELPA for Emacs, here is a quick summary before I dive into the new features:

The Selected Window Accent Mode is an Emacs package designed to visually distinguish the currently selected window by applying a unique accent color to its fringes, mode line, header line, and margins.

https://github.com/captainflasmr/selected-window-accent-mode

Transient Map for Quick Access

In the latest release of Selected Window Accent Mode, version 0.8.0, users of Emacs 28.1 and above can enjoy the convenience of a transient map. This new feature allows you to access a transient menu by simply pressing `C-c w`:

(global-set-key (kbd "C-c w") 'selected-window-accent-transient)

Upon invoking this key binding, the following transient menu will be displayed:

Release Highlights

v0.8.0 | 2024-07-15

Transient Menu: A transient menu has been added for interactive adjustments, simplifying the process of tweaking settings on the fly. Refer to the README for detailed usage instructions.
Emacs Dependency: The Emacs dependency has been upgraded to version 28.1.
Custom Foreground Accent Color: A new variable, `selected-window-accent-fg-color`, has been introduced for setting a custom foreground accent color.
Enhanced Customization Options:
- `selected-window-accent-foreground-adjust-factor`
- `selected-window-accent–use-complementary-color`
- `selected-window-accent–foreground-invert-state`
- `selected-window-accent–foreground-offset`
Foreground Brightness Functions:
- `selected-window-accent-flip-foreground-color`
- `selected-window-accent-increment-foreground-color`
- `selected-window-accent-decrement-foreground-color`
- `selected-window-accent-toggle-complementary-color`
- `selected-window-accent-toggle-tab-accent`
- `selected-window-accent-toggle-smart-borders`
Configuration Export: A new function, `selected-window-accent-output-selected-window-accent-settings`, allows you to output the current settings for easy copying and pasting into your Emacs init file.
Miscellaneous: Various improvements and refactoring have been made to enhance the overall functionality and maintainability.

v0.7.0 | 2024-07-09

Compatibility Fixes: Addressed issues with other packages and restored modeline height when switching between modes.
Issue Resolutions:
- ISSUE #4: Resolved compatibility issues with other packages.
- ISSUE #3: Fixed problems causing the package to break fringes.

With these updates, Selected Window Accent Mode continues to offer increased customization and improved user experience. Stay tuned for more exciting features in the upcoming versions! 😀

Emacs Blog 2 Year Anniversary - First Post Revisit - Create Local Offline ELPA MELPA ORG

James Dyer — Mon, 15 Jul 2024 21:00:00 +0100

I’ve noticed that my Emacs blog is now almost 2 years old!

Is there something absurd about writing about a text editor in that very text editor for such a long period? - I think the answer to this is clearly…, no!

My first post was on 2022-07-15 and this will be blog number 97.

And yes before you ask, how do I know this to be true?, well I found out the Emacs way!

I recorded its inception date in org-agenda, so I saw this date creep up this week :

** blog anni :james:web:
<2022-07-15 .+1y>

The date of my first post is in an org drawer in my single Emacs blog org file:

:EXPORT_HUGO_LASTMOD: 2022-07-15

and the blog number?, well, I org-copy-visible’d my org blog file of all the top level org headers, pasted into the scratch buffer, flush-line’d out all the TODO entries, then finally entered (display-line-numbers-mode) to get the number of lines (I suspect there might be an easier way to do this 😀)

I also wrote this post ahead of time and to remind me when to post I created an org schedule entry as follows:

** TODO post 2 yr emacs blog post
SCHEDULED: <2024-07-15 Mon>

and appeared in the agenda as :

Monday 15 July 2024 W29
aab--calendar:Scheduled: TODO post 2 yr emacs blog post

and in (cfw:open-org-calendar) as :

+-------------------------+
| 15 (3) |
| TODO post 2 yr emacs |
| blog anni |
| |
| |
| |
+-------------------------+

Living an Emacs life and especially partially through org means that any and all information can be easily extracted let alone initially logged, the basic text format is so simple and uniform that all the data items above were pretty much extracted using the same mechanism through Emacs.

Anyway enough of all that, in celebration of being able to maintain some level of blogging discipline for 2 years, I decided to revisit my very first post, which was on how to create an offline version of the major Emacs repositories, namely:

ELPA
MELPA
ORG

As it turns out this post is still quite relevant as from time to time, I need an offline version for an Emacs setup without an internet connection.

So lets re-post!, just for fun!, including the bash script that I still use:

Steps to locally download emacs packages for offline installation.

Local ELPA MELPA ORG

#! /bin/bash
cd ~
mkdir -p emacs-pkgs/melpa
mkdir -p emacs-pkgs/elpa

echo
echo "updating MELPA..."
echo
rsync -avz --delete --progress rsync://melpa.org/packages/ ~/emacs-pkgs/melpa/.

echo
echo "updating ELPA..."
echo
rsync -avz --delete --progress elpa.gnu.org::elpa/. ~/emacs-pkgs/elpa

# org (currently no rsync support)
echo
echo "updating ORG..."
echo
cd ~/emacs-pkgs
git clone https://git.savannah.gnu.org/git/emacs/org-mode.git
# wget -r -l1 -nc -np https://orgmode.org/elpa

I then copy the emacs-pkgs directory to the offline target machine and change the default package manager archives to point to these packages.

Modify .emacs in the following manner commenting out the online package communication:

;; (setq package-archives '(("melpa" . "https://melpa.org/packages/")
;; ("org" . "https://orgmode.org/elpa/")
;; ("elpa" . "https://elpa.gnu.org/packages/")))

(setq package-archives '(("melpa". "~/emacs-pkgs/melpa")
 ("org" . "~/emacs-pkgs/elpa")
 ("elpa" . "~/emacs-pkgs/org-mode/lisp")))

Creating a Spelling Transient

James Dyer — Fri, 12 Jul 2024 08:25:00 +0100

I really want to finally get to grips with my spelling / dictionary set-up.

I’m happy with jinx instead of flyspell. I like powerthesaurus and, of course, dictionary-lookup-definition. It is mainly the keybindings I want to finally settle on. I have been moving them around for a while now but haven’t really established something comfortable.

jjjNow Emacs 29 comes with transient, which is the keyboard-driven interface used by Magit, I am going to see if I can fit my spelling keybindings into a more menu-driven system. I have tried Hydra in the past but found I wasn’t really using it. Now that transient is built-in and the syntax seems simple, let’s give it a go!

Here are my original keybindings:

(use-package jinx)
(use-package powerthesaurus)
(global-set-key (kbd "M-s y") 'powerthesaurus-lookup-synonyms-dwim)
(global-set-key (kbd "M-s a") 'powerthesaurus-lookup-antonyms-dwim)
(global-set-key (kbd "M-s x") 'jinx-mode)
(global-set-key (kbd "M-s c") 'jinx-correct)
(global-set-key (kbd "M-s d") 'dictionary-lookup-definition)

and converted into :

(use-package jinx)

(use-package powerthesaurus
 :init
 (require 'transient)
 (transient-define-prefix my/transient-spelling ()
 "Spelling commands"
 ["Spelling"
 ["Lookups"
 ("y" "Synonyms" powerthesaurus-lookup-synonyms-dwim)
 ("a" "Antonyms" powerthesaurus-lookup-antonyms-dwim)]
 ["Spelling Tools"
 ("x" "Jinx" jinx-mode)
 ("c" "Jinx correct" jinx-correct)]
 ["Dictionary"
 ("d" "Lookup" dictionary-lookup-definition)]
 ["Miscellaneous"
 ("q" "Quit" transient-quit-one)]])
 :bind
 ("C-c s" . my/transient-spelling))

and produces the following menu:

Well that was pretty simple, lets see how this goes and if I might then think about translating some more of my keybindings to transient menus.

WOWEE v0.3.3

James Dyer — Fri, 05 Jul 2024 07:58:00 +0100

More tinkering and enhancements to some AutoHotKey scripts with WOWEE to allow some emacs keybindings throughout the realm of Windows.

WOWEE is a set of AutoHotKey scripts designed to bring Emacs-like commands and keybindings to the Windows operating system. Based on the concept of EWOW (Emacs Way of Operating Windows), WOWEE allows you to use Emacs-style navigation and commands throughout your Windows environment.

I have this on github : https://github.com/captainflasmr/wowee

As I have been playing ergo for a little while with Emacs I decided to bring in some of this functionality, for example some common ergo keybindings.

Ergonomic keyboard layout options

Additional AHK files that can be run in parallel with the main wowee.ahk file if you would prefer some extra ergonomic mappings.

For example it is common to map the Caps Lock key to the Control key to avoid the dreaded Emacs pinky, which can be performed by running up :

wowee--caps_to_ctrl.ahk

I prefer to map the right hand Alt key to the Control key by running:

wowee--ralt_to_ctrl.ahk

Both can also be run if desired!

Whats New

Version 0.3.3 <2024-07-01 Mon>

A little support for Notepad++:

isearch
comment line

Version 0.3.2 <2024-07-01 Mon>

Separated individual ergonomic key-mappings as thus:

wowee–caps_to_ctrl.ahk
wowee–ralt_to_ctrl.ahk

These are extra files that can be run in addition to the main wowee.ahk for some common ergonomic keyboard Emacs mappings.

Version 0.3.1 <2024-06-30 Sun>

This commit has added windows, frames support

kill frame (C-x c)
split window vertically (C-x 3)
maximize window (C-x 1)
next window (C-x o)
suspend frame (C-z)
reorganisation of kanban
reorganisation of commands.ahk to better group

kanban

This kanban board is keeping track of those original EWOW functions.

The IGNORE column includes functions that I am definitely not going to implement.

The EXTRA section are additional commands that I am adding.

There is a prefix type indicator for each command referring to the specific type:

and any command with an asterisk is an unconventional Emacs keybinding which will probably get fixed sometime in the future!

TODO	DOING	DONE	IGNORE
(C) REGION COMMANDS	(VS) VISUAL STUDIO	(C) MOTION COMMANDS	(C) JUMPING AROUND COMMANDS
- (C) mark_word	- (VS) recenter_line (C-l)	- (C) forward_char (C-f)	- (C) scroll_left
- (C) yank_pop	- (VS) indent_line (C-i)	- (C) backward_char (C-b)	- (C) scroll_right
- (C) kill_region	(VC) VSCODE	- (C) forward_word (M-f)	(C) NEWLINE AND INDENT COMMANDS
- (C) delete_backward_char	- (VC) isearch_backwards (C-r)	- (C) backward_word (M-b)	- (C) open_line
- (C) kill_word	- (VC) isearch_forwards (C-s)	- (C) next_line (C-n)	(C) EDIT COMMANDS
- (C) kill_whole_line	- (VC) comment_line (C-;)	- (C) previous_line (C-p)	- (C) transpose_chars
(C) NEWLINE AND INDENT COMMANDS	- (VC) recenter_line (C-l)	(C) JUMPING AROUND COMMANDS	- (C) transpose_words
- (C) newline	(N++) NOTEPAD++	- (C) scroll_down (C-v)	- (C) transpose_lines
- (C) delete_indentation	(E) PROGRAM SPECIFIC PRESETS	- (C) scroll_up (M-v)	(C) CASE CONVERSION COMMANDS
(C) EDIT COMMANDS	(E) ERGO PRESET SELECTION	- (C) move_beginning_of_line (C-a)	- (C) upcase_region
- (C) redo		- (C) move_end_of_line (C-e)	- (C) downcase_region
- (C) query_replace		- (C) beginning_of_buffer (M-<)	- (C) upcase_word
- (C) overwrite_mode		- (C) end_of_buffer (M->)	- (C) downcase_word
- (E) isearch-yank-word-or-char		- (C) goto_line (M-g g)	- (C) capitalize_word
(C) INSERT PAIRS COMMANDS		(C) REGION COMMANDS	(C) MACRO RECORDING COMMANDS
- (C) insert_parentheses		- (E) mark_whole_line (M-s ,)	(C) ADD IGNORE FRAMES
- (C) insert_comment		- (C) mark_whole_buffer (C-x h)	(C) ADD MOUSE EVENTS
- (C) indent_new_comment_line		- (C) kill_ring_save (M-w)
(C) OTHER COMMANDS		- (C) yank (C-y)
- (C) shell		- (C) delete_char (C-d)
- (C) shell_command		- (C) backward_kill_word (M-BKSP)
- (C) facemenu		- (C) kill_line (C-k)
- (C) help		(C) NEWLINE AND INDENT COMMANDS
(C) SYSTEM COMMANDS		- (C) indent_for_tab_command (C-i)
- (C) ignore		(C) EDIT COMMANDS
- (C) repeat		- (C) undo_only (C-/)
(C) UNIVERSAL ARGUMENT COMMANDS		- (C) search_forward (C-s)
(C) FILES COMMANDS		- (C) search_backward (C-r)
- (C) write_file		(C) SYSTEM COMMANDS
- (C) find_file		- (C) set_mark_command (C-SPC)
- (C) dired		- (C) set_c-x_command (C-x)
(C) WINDOWS FRAMES COMMANDS		- (C) keyboard_quit (C-g)
- (C) delete_window		(C) FILES COMMANDS
- (C) split_window		- (*C) save_buffer (C-x s)
- (C) previous_window		(C) WINDOWS FRAMES COMMANDS
(C) ADD HOOKS		- (*C) kill_frame (C-x c)
(C) ADD GENERIC GOTO LINE		- (C) next_window (C-x o)
(C) ADD KILL RING		- (C) suspend_frame (C-z)
(VC) VSCODE		(C) ADD C-X (C-x)
- (VC) indent_line (C-i)		(VS) VISUAL STUDIO
		- (VS) isearch_backwards (C-r)
		- (VS) isearch_forwards (C-s)
		- (VS) comment_line (C-;)
		- (VS) split window vert (C-x 3)
		(N++) NOTEPAD++
		- (N++) isearch_backwards (C-r)
		- (N++) isearch_forwards (C-s)
		- (N++) comment_line (C-;)

WOWEE v0.3.0

James Dyer — Fri, 28 Jun 2024 10:19:00 +0100

I have been continuing to tinker with this project over the last week…

https://github.com/captainflasmr/wowee

Overview

WOWEE is a set of AutoHotKey scripts designed to bring Emacs-like commands and keybindings to the Windows operating system. Based on the concept of EWOW (Emacs Way of Operating Windows), WOWEE allows you to use Emacs-style navigation and commands throughout your Windows environment.

Whats New

Version 0.3.0 [2024-06-28 Fri]

This commit has split out ahk files into apps, core and init:

Added comment-line
Added mark-whole-buffer
Refined isearch
Added application specific bindings in keybinds-apps.ahk for Visual Studio and VSCode
Update README to reflect design changes
Added beginning_of_buffer and end_of_buffer core mappings
Added mark_whole_buffer core mapping

Version 0.2.0 [2024-06-26 Wed]

This commit introduces several new functions to enhance the usability and functionality of the `commands.ahk` script. Notable additions include:

Implementation of `isearch_backward` and `isearch_forward` functions for improved search capabilities, allowing for backwards and forwards in-document searches with initialization and continuation logic.
Addition of `recenter_line`, `indent_line`, and `backward_kill_word` functions to enrich text editing commands.
Enhancement of `select_line` and `goto_line` functions for better line selection and navigation.
The `quit_g` function extends quitting capabilities to also reset the `selecting` and `searching` states.
Modifications to `next_lines` and `previous_lines` to increase the number of lines navigated with each command from 3 to 6, improving scroll efficiency.
Update to `kill_ring_save` to include an escape key press, ensuring a more comprehensive cleanup post-operation.
Improved the README.org kanban to more easily differentiate between command sections and to define those commands I am not implementing (IGNORE) and those additional commands (EXTRA)

Version 0.1.0 [2024-06-19 Wed]

Initial version

Features

Emacs-like commands and keybindings in Windows
Based on EWOW – Emacs Way of Operating Windows
Written in AutoHotKey v2
Includes various Emacs style navigation commands
Ergonomic keyboard layout options
Easily add your own keybindings by modifying AHK source files
Bindings bespoke to individual applications

My current thoughts

Bindings bespoke to individual applications

I am playing around with the idea of application specific bindings within the keybinds.ahk file, for example something like :
```
 ;; -------------
 ;; Visual Studio
 ;; -------------
 ;; Shortcut rebindings:
 ;;
 ;; Control+p Control+s : Text Editor : Incremental Search
 ;; Control+p Control+r : Text Editor : Incremental Search Reverse
 ;; Control+p Control+l : Text Editor : Scroll Recenter
 ;; Control+p Control+f : Text Editor : Format selection

 #HotIf WinActive("ahk_class VisualStudio")
 ^r::isearch_backward("{Shift down}{F3}{Shift up}" "^p^r")
 ^s::isearch_forward("{F3}" "^p^s")
 ^l::recenter_line()
 ^i::indent_line()
 ^+i::indent_line()
```
These will be placed in a separate ahk file called keybinds-apps.ahk.

The comments would indicate which commands require re-bindings, or redefining the shortcuts. For example, in Visual Studio, Control+I is an incremental search which in emacs is used for multiple actions including indentation, cycling, e.t.c, so at times rather than relying on either default application keybindings or the general windows keybindings an explicit mapping may be required for full functionality.

So as part of the application definition, why not add in the re-mappings in a comment!

Also I might have to create some more generic functions to accept arguments defining application specific commands, as demonstrated above with isearch_forward and isearch_backward.

As part of this I might have to expand the kanban per application, or maybe separate kanbans on which functions have been implemented.

kanban

This kanban board is keeping track of those original EWOW functions.

The IGNORE column includes functions that I am definitely not going to implement.

The EXTRA section are additional commands that I am adding.

TODO	DOING	DONE	IGNORE
CORE REGION COMMANDS	—- VISUAL STUDIO —-	CORE MOTION COMMANDS	- scroll_left
- mark_word	- recenter_line	- forward_char	- scroll_right
- kill_region	- indent_line	- backward_char	- open_line
- yank_pop	—- VSCODE —-	- forward_word	- transpose_chars
- delete_backward_char	- isearch_backwards	- backward_word	- transpose_words
- kill_word	- isearch_forwards	- next_line	- transpose_lines
- kill_whole_line	ADD PROGRAM SPECIFIC PRESETS	- previous_line	CORE CASE CONVERSION COMMANDS
CORE NEWLINE AND INDENT COMMANDS		CORE JUMPING AROUND COMMANDS	- upcase_region
- newline		- scroll_down	- downcase_region
- delete_indentation		- scroll_up	- upcase_word
CORE EDIT COMMANDS		- move_beginning_of_line	- downcase_word
- redo		- move_end_of_line	- capitalize_word
- query_replace		- beginning_of_buffer	CORE MACRO RECORDING COMMANDS
- overwrite_mode		- end_of_buffer	CORE ADD IGNORE FRAMES
CORE INSERT PAIRS COMMANDS		- goto_line	CORE ADD MOUSE EVENTS
- insert_parentheses		- mark_whole_line
- insert_comment		- mark_whole_buffer
- indent_new_comment_line		- kill_ring_save
CORE OTHER COMMANDS		- yank
- shell		- delete_char
- shell_command		- backward_kill_word
- facemenu		- kill_line
- help		- indent_for_tab_command
CORE SYSTEM COMMANDS		- undo_only
- ignore		- search_forward
- repeat		- search_backward
CORE DIGIT ARGUMENT COMMANDS		- set_mark_command
CORE FILES COMMANDS		- set_cx_command
- write_file		- keyboard_quit
- find_file		- save_buffer
- dired		CORE ADD C-X
CORE WINDOWS FRAMES COMMANDS		- isearch_backwards
- kill_frame		- isearch_forwards
- delete_window		- comment_line
- split_window		- comment_line
- next_window
- previous_window
- suspend_frame
CORE ADD HOOKS
ADD GENERIC GOTO LINE
CORE ADD KILL RING
- recenter_line
- indent_line
EXTRA ERGO PRESET SELECTION
EXTRA
- ctrl_mapping

Usage

Install AutoHotKey: Download and install AutoHotKey from AutoHotKey’s official website.
Run WOWEE: Double-click on the `wowee.ahk` script to start WOWEE. Once running, Emacs commands will be available in your Windows environment.
Quit WOWEE: To quit WOWEE, right-click the AutoHotKey icon in the task tray and select “Exit.”

Configuration

WOWEE is composed of several AutoHotKey scripts, each serving a specific purpose to replicate Emacs functionalities:

wowee.ahk

The top level script to be run, contains the following scripts along with some potential ergonomic key-mappings which if not desired can be commented out:

RAlt::Control
CapsLock::Control
#Include fundamental.ahk
#Include commands.ahk
#Include keybinds-apps.ahk
#HotIf !WinActive("ahk_class Emacs")
#Include keybinds-core.ahk
#Include keybinds-init.ahk
#HotIf

fundamental.ahk

This script provides a set of fundamental functions and variables that are used to implement Emacs-like commands and keybindings.

commands.ahk

This script includes the basic implementation of Emacs commands.

commands_util.ahk

This script contains simple utility functions used by the command scripts.

keybinds-core.ahk

This script defines the default core keybindings for Emacs-like commands, which will be a fallback for any windows application.

keybinds-apps.ahk

This script defines the application specific commands, typically commands that have been remapped to accommodate the chosen commands.

Comments within the ahk file indicate the potential re-mappings.

keybinds-init.ahk

Analogous to the init.el file or Emacs init file in which all the users bespoke keybindings will exist. An example of my preferred keybindings has been supplied.

WOWEE - Windows Operating With Emacs Enhancements

James Dyer — Mon, 24 Jun 2024 21:00:00 +0100

My Emacs usage on Windows seems to be more prevalent at the moment, and I’m having to drop into Visual Studio for C# development.

Emacs keybindings are so ingrained into my muscle memory that it would be rather pleasant to leverage this digital advantage when plonking around Windows for all applications.

In Visual Studio this apparently, like most IDE’s, can be accomplished via a plug-in, but I think I would like a more wholistic versatile approach, by for example, having Emacs keybindings applied at a global Windows level.

So how do I accomplish this?, I prodded the interwebs and firstly came across XKeymacs:

XKeymacs provides key bindings like Emacs for applications running on Microsoft Windows. You can also configure bindings for each application.

On running the binary it looks very comprehensive and has a nice intuitive GUI. However I would like a project I could get my teeth into and I was struggling to build it in a modern version of Visual Studio, this may be something I’ll have another look at in the future. Possibly though my quick abandonment of this idea was more related to an idea I had regarding AutoHotKey (a scripting language which can provide easy keyboard shortcut mapping) and a language that I am already familiar with.

As it turns out there is already an AutoHotKey project that suits my needs and that is EWOW – Emacs Way of Operating Windows, it is defined as follows:

allows Emacs-like commands and keybinds (almost) everywhere in Windows

keyboard macros

prefix digit-argument

ex. C-3 C-n -> go 3 lines down

Emacs-style region selection (i.e. set-mark-command)

… etc

It is essentially a set of AutoHotkey scripts and my AHK familiarity could mean this to be an ideal project to take a closer look at and to have a tinker around.

This project also seems to be well thought out and comprehensive and even provides bonus functionality that I wouldn’t have expected, like hooks and even macros!!

It is written however in AutoHotkey V1 and although still currently available it is deprecated and v2 is considered now the main supported version. V2 is a significant rewrite of the the AHK syntax and to convert EWOW from v1 to v2 might take some significant effort. I had an initial look to see what was involved and used it as an exercise to start to understand both the magnitude of the porting task and to get familiar generally with EWOW. More than anything though this activity surfaced an idea for a new project aimed at implementing Emacs-like commands on Windows, focusing especially on the commands I find myself wanting to use most frequently.

My initial idea is to lean heavily on EWOW by taking the basic structure and design principles which could accommodate some future augmentation, such as hooks, macros e.t.c and to declare a form of AHK bankruptcy and start almost from scratch and progress from an AHK V2 base. Initially I will try and add the most common simple commands using EWOW as a guide and then build up over a period of time to something with more bells on it.

I have created a new project with a nod to the name of EWOW, it is defined below and I will look to gradually introduce more Emacs functionality over the next few months and especially focussing on those commands I keep reaching for when faffing around with Visual Studio.

I have also added a kanban board (using org-kanban, which I will discuss more in a future post) that lists all the EWOW implemented key functions and indicates which ones have been ported. As I become more familiar with this project, I will start to define its scope more clearly. This will likely include deciding on the functionality I choose not to implement. I would like to focus as much as possible on simplicity, with an ergonomic approach in mind. For example, I’m considering options such as mapping Caps and RAlt to Control, providing the option for a Vim-style keybinding, and the ability to create presets through textual modifications of AHK files.

WOWEE - Windows Operating With Emacs Enhancements

https://github.com/captainflasmr/wowee

Features

Emacs-like commands and keybindings in Windows
Based on EWOW – Emacs Way of Operating Windows
Written in AutoHotKey v2
Includes various Emacs style navigation commands

kanban

TODO	DOING	DONE
scroll_left	jumping around commands	motion commands
scroll_right		forward_char
goto_line		backward_char
region commands		forward_word
mark_word		backward_word
mark_whole_line		next_line
mark_whole_buffer		previous_line
kill_region		scroll_down
yank_pop		scroll_up
delete_backward_char		move_beginning_of_line
kill_word		move_end_of_line
backward_kill_word		beginning_of_buffer
kill_whole_line		end_of_buffer
newline and indent commands		kill_ring_save
newline		yank
open_line		delete_char
indent_for_tab_command		kill_line
delete_indentation		undo_only
edit commands		set_mark_command
redo		set_cx_command
transpose_chars		keyboard_quit
transpose_words		save_buffer
transpose_lines
query_replace
search_forward
overwrite_mode
case conversion commands
upcase_region
downcase_region
upcase_word
downcase_word
capitalize_word
insert pairs commands
insert_parentheses
insert_comment
indent_new_comment_line
other commands
shell
shell_command
facemenu
help
system commands
ignore
repeat
digit argument commands
macro recording commands
files commands
write_file
find_file
dired
windows frames commands
kill_frame
delete_window
split_window
next_window
previous_window
suspend_frame
add hooks
add ignore frames
add goto line
add kill ring
add mouse events
add C-x

Usage

Install AutoHotKey: Download and install AutoHotKey from AutoHotKey’s official website.
Run WOWEE: Double-click on the `wowee.ahk` script to start WOWEE. Once running, Emacs commands will be available in your Windows environment.
Quit WOWEE: To quit WOWEE, right-click the AutoHotKey icon in the task tray and select “Exit.”

Configuration

WOWEE is composed of several AutoHotKey scripts, each serving a specific purpose to replicate Emacs functionalities:

fundamental.ahk

This script provides a set of fundamental functions and variables that are used to implement Emacs-like commands and keybindings.

commands.ahk

This script includes the basic implementation of Emacs commands.

commands_util.ahk

This script contains simple utility functions used by the command scripts.

keybinds.ahk

This script defines the default keybindings for Emacs-like commands.

Installation and Setup

Download WOWEE: Download the WOWEE scripts from the repository.
Extract Files: Extract the files to a directory of your choice.
Run the Script: Double-click `wowee.ahk` to start using WOWEE.

Customization

Editing Keybindings

You can customize the keybindings by editing the `keybinds.ahk` file. Open the file in any text editor and modify the keybindings according to your preferences. Refer to the AutoHotKey documentation for the syntax and available key options.

Adding New Commands

To add new commands, you can edit the `commands.ahk` and `commands_util.ahk` files. Define your new commands and utility functions, and then bind them to keys in `keybinds.ahk`.

Troubleshooting

If you encounter any issues while using WOWEE, try the following steps:

Check AutoHotKey Version: Ensure you have the latest version of AutoHotKey installed.
Script Errors: If there are errors in the script, AutoHotKey will usually display a message with details. Use this information to debug and fix the issue.
Conflicting Programs: Some programs might have conflicting keybindings. Try closing other programs to see if the issue is resolved.

Contributing

Contributions to WOWEE are welcome! If you have suggestions for improvements or want to add new features, feel free to submit a pull request.

Fork the repository
Create your feature branch (`git checkout -b feature/YourFeature`)
Commit your changes (`git commit -am ‘Add your feature’`)
Push to the branch (`git push origin feature/YourFeature`)
Create a new pull request

License

WOWEE is licensed under the MIT License. See the LICENSE file for more details.

Acknowledgements

Special thanks to the creator of EWOW, from whom I have derived significant inspiration: https://github.com/zk-phi/ewow

Special thanks to the creators of AutoHotKey and the Emacs community for their inspiration and contributions to keyboard efficiency.

Contact

For any questions or issues, please open an issue on the GitHub repository or contact the maintainer at captainflasmr@gmail.com

Enjoy using WOWEE and bring the power of Emacs navigation to your Windows experience!

Using A Mechanical Keyboard, Literally On A Laptop!

James Dyer — Sat, 08 Jun 2024 16:55:00 +0100

The next stage on my quest to mitigate any RSI issues when using Emacs on a laptop is to see if it is a viable option to use a mechanical keyboard on a laptop.

When I mean “on a laptop” I literally mean ON the laptop!!

My idea is to buy a smallish portable mechanical keyboard and just plonk it (technical term) over my current laptop keyboard.

At the moment I know nothing about mechanical keyboards, I just know from an RSI perspective they are generally a good idea. I do miss the feeling of key travel and I am aware at times I’m tapping too hard on my laptop keyboard due to their shallow depth.

So here is the keyboard in its fully installed glory - extreme plonkification!

I however encountered notable difficulties that depended largely on the placement of the keyboard’s feet in relation to the laptop’s built-in keyboard. Spamming of a single key press was a common issue and was due to my built-in laptop still being enabled when the mech-keyboard was plugged in.

Simply solved however with a bash script to disable the laptop keyboard when the mech is plugged in.

Note: this will be SwayWM specific but can easily be adapted by replacing the swaymsg command.

KEYBOARD_CONNECTED=0

while :
do
 if [[ -L "/dev/input/by-id/usb-SEMICO_USB_Gaming_Keyboard-event-kbd" ]]; then
 if [[ $KEYBOARD_CONNECTED == 0 ]]; then
 KEYBOARD_CONNECTED=1
 notify-send -t 3000 "KEYBOARD CONNECTED!"
 swaymsg input 1:1:AT_Translated_Set_2_keyboard events disabled
 fi
 else
 if [[ $KEYBOARD_CONNECTED == 1 ]]; then
 KEYBOARD_CONNECTED=0
 notify-send -t 3000 "KEYBOARD DISCONNECTED!"
 swaymsg input 1:1:AT_Translated_Set_2_keyboard events enabled
 fi
 fi

 sleep 2
done

Now I can use Emacs on a laptop without the drawbacks of using a shallow laptop keyboard.

The next ergo improvement might now be trying to find a better resting hand position as the new mech-keyboard is raised by an inch or so, but that will be for another ergpost…

New Package, xkb-mode, to edit X Keyboard Extension Files

James Dyer — Fri, 24 May 2024 16:12:00 +0100

Based on my recent forays into ergonomic key-mapping in Emacs for SwayWM, and effectively for any Wayland compositor or X11-based system using the X Keyboard Extension (XKB) standard, I realized that there doesn’t seem to be an Emacs mode to edit these keyboard configuration files (*.xkb). This is surprising, considering they have been around for more than 30 years!

So I wrote one, and its on MELPA.

Summary

A Major mode for editing X Keyboard Extension (XKB) files

xkb-mode is an Emacs major mode designed to facilitate the editing of XKB files, providing syntax highlighting and other useful editing features tailored specifically for XKB file format. Whether you’re customizing keyboard layouts or diving into the details of X Keyboard Extension configurations, xkb-mode aims to make the task more efficient and enjoyable.

Whats New

Version 0.2.0

Correct version from 0.6.0 to 0.2.0 to reflect the actual stage of development.
Remove the ‘Alternatives’ section, streamlining the introduction.
Improve code formatting for better readability and maintenance. This includes more consistent use of newlines and arrangement of font lock faces.
Use `#’` prefix for function symbols as a best practice, explicitly marking `xkb-indent-line` as a function, enhancing code clarity.

Screenshot

Features

Syntax highlighting for XKB-specific keywords, modifiers, and structures.
Custom indentation logic for XKB code blocks.
Auto-detection of .xkb files to automatically enable the mode.

Installation

To install xkb-mode, you can use the following methods:

use-package (MELPA)

(use-package xkb-mode)

use-package (emacs 29)

Put the following into your emacs init file:

(use-package xkb-mode
 :vc (:fetcher github :repo "captainflasmr/xkb-mode"))

from source

Download the `.el` file and place it in your Emacs `load-path`.

Then either manually load it or add it to your configuration to be loaded at startup.

(require 'xkb-mode)

Usage

Opening any .xkb file with Emacs should automatically enable xkb-mode, providing you with syntax highlighting and indentation support for editing XKB files.

Customization

Currently, xkb-mode provides a basic set of features optimized for general usage. Future versions may include customizable options based on user feedback.

Contributing

Contributions to xkb-mode are welcome! Whether it’s bug reports, feature suggestions, or code contributions, feel free to reach out or submit pull requests on GitHub.

License

xkb-mode is available under the terms of the GNU General Public License v3.0. See the included LICENSE file for more details.

Contact

For any questions or suggestions, please contact James Dyer at captainflasmr@gmail.com.

Visit our GitHub repository: https://github.com/captainflasmr/xkb-mode for more information and updates.

This README provides a concise but comprehensive overview of what the `xkb-mode` package is, how to get it installed, and how to use it, alongside encouraging community contributions and providing licensing info.

ISSUES

NONE

TODOs / ROADMAP

TODO function to set xkb file to latched sticky keys

TODO function to set xkb file locked sticky keys

TODO function to map RAlt to Ctrl

Testing

See CHANGELOG.org

Writing Elisp to Find Available Keybindings in a Sway Config

James Dyer — Thu, 16 May 2024 18:25:00 +0100

I thought I would provide an example of how I typically use elisp to make my life easier (well eventually - I still need to write the function after all!)

@startwbs
!theme materia
* Sway config
** parse file
** collect $mod keybindings
** sort
** output
@endwbs

In the example below, I wanted to find a simple elispy method to determine which Sway keybindings are available, specifically those that utilize the $mod key (typically Mod4/Super). Running out of available $mod keybindings in Sway, and then realizing upon reload that I have inadvertently added a duplicate keybinding, can be quite frustrating.

When this happens, I usually then have to resort to scrolling through the config file or using `isearch` to determine which keybindings are available. This can be tedious and is made more difficult in that my keybindings are not listed alphabetically but are grouped by function.

I am having a similar problem with Emacs but that is where the package free-keys comes in handy, listing the free and available keybindings.

I initially wanted to create something similar to free-keys for Sway, but by parsing the Sway configuration file and generating a report.

A Sway config file is typically defined in the following format:

# Set Defaults
set $mod Mod4
set $left h
set $down j
set $up k
set $right l

# Key bindings
bindsym $mod+b exec toggle_waybar.sh
bindsym $mod+c exec screen-record.sh
bindsym $mod+e exec thunar ~/DCIM/Camera
bindsym $mod+m exec emacs
bindsym $mod+n exec firefox
bindsym $mod+p exec wl-color-picker
bindsym $mod+q kill
bindsym $mod+return exec $term

# Change window focus
bindsym $mod+Left focus left
bindsym $mod+Down focus down
bindsym $mod+Up focus up
bindsym $mod+Right focus right
bindsym $mod+$left focus left
bindsym $mod+$down focus down
bindsym $mod+$up focus up
bindsym $mod+$right focus right

For now, to keep things simple, I will focus solely on writing elisp to list the current Sway keybindings that use Mod4 or any alias for Mod4 in alphabetical order. Then, by visually scanning and leveraging the human brain’s familiarity with the alphabet, I can determine which keybindings are unused!

For example, my new elisp function could yield the following typical output for the sway snippet defined above:

Mod4+Down
Mod4+Left
Mod4+Right
Mod4+Up
Mod4+b
Mod4+c
Mod4+e
Mod4+h
Mod4+j
Mod4+k
Mod4+l
Mod4+m
Mod4+n
Mod4+p
Mod4+q
Mod4+return

Now I should be able to more easily gauge which bindings are not used.

Of course my full Sway config has many more Mod4 keybindings and when running the elisp function defined below I realised I now only have 3 alphabetical mappings left for $mod - eeek!, but at least I now know what they are and don’t have to go trawling through the config anymore.

…wait, um, just as a side note, while I’m editing this blog post, it has just occurred to me (pardon the pun), can I use occur, push to a buffer then re-order, mmmm….., well lets ignore that thought for now, I want to dig into some elisp, its a learning experience after all!!

Here is the elisp:

(defun swaywm-list-mod-bindsyms (path)
 "List all bindsyms that start with $mod or its resolved value in the SwayWM config file at PATH."
 (interactive "fSway config file path: ")
 (with-temp-buffer
 (insert-file-contents path)
 (goto-char (point-min))
 (let ((vars nil)
 (bindsyms nil))
 ;; Collect variable definitions
 (while (re-search-forward "^set \\$\\([a-zA-Z0-9_]+\\) \\(.*\\)$" nil t)
 (let ((var (match-string-no-properties 1))
 (value (match-string-no-properties 2)))
 (setq vars (cons (cons var value) vars))))
 ;; Prepare to translate $mod and other keys
 (let* ((mod (cdr (assoc "mod" vars)))
 (left (cdr (assoc "left" vars)))
 (down (cdr (assoc "down" vars)))
 (up (cdr (assoc "up" vars)))
 (right (cdr (assoc "right" vars)))
 (mod-re (format "\\(%s\\|$mod\\)" (regexp-quote mod))))
 (goto-char (point-min))
 ;; Collect all bindings that start with $mod or its resolved value
 (while (re-search-forward (format "^bindsym %s\\+\\([^ ]+\\) \\(.*\\)$" mod-re) nil t)
 (let* ((mod-key (match-string-no-properties 1))
 (action (match-string-no-properties 2))
 (full-key (concat mod "+" action)))
 ;; Replace variable references in keys
 (setq full-key (replace-regexp-in-string "\\$left" left full-key))
 (setq full-key (replace-regexp-in-string "\\$down" down full-key))
 (setq full-key (replace-regexp-in-string "\\$up" up full-key))
 (setq full-key (replace-regexp-in-string "\\$right" right full-key))
 ;; Replace $mod with the actual mod key or keep as $mod for clarity
 (setq full-key (replace-regexp-in-string "\\$mod" mod full-key))
 ;; Collect the key-action pair
 (setq bindsyms (cons (format "%s" full-key) bindsyms)))))
 ;; Return reversed to maintain order
 (mapconcat 'identity (sort (nreverse bindsyms) 'string-lessp) "\n"))))

and to call just by:

(swaywm-list-mod-bindsyms "~/.config/sway/config.d/default")

or interactively.

I might evolve this a little more over the coming weeks (and actually maybe this is where occur and in-house Emacsing may at last have its limitations!). There is potentially a lot to do, for example some such improvements could be :

iterate over multiple files to accommodate a typical distributed Sway configuration set
show bindings that are free - just like free-keys
make more generic for multiple different types of config files containing bindings such as :
- hyprland
- other tiling window managers that typically define bindings in config files
- emacs ?!
translate all aliases not just the common $left, $right, $up, $down

Here is a mini manual for this function :

Manual for swaywm-list-mod-bindsyms
- Synopsis
- Description
- Parameters
- Usage
- Example
- Notes

Manual for swaywm-list-mod-bindsyms

List and sort bindsym commands from a SwayWM configuration file that are assigned to the mod key.

Synopsis

(swaywm-list-mod-bindsyms PATH)

Description

The `swaywm-list-mod-bindsyms` function parses a specified SwayWM configuration file and extracts all `bindsym` commands that begin with the modifier key (usually designated as `$mod` in SwayWM configurations). The resolution of the `$mod` key, along with other potential sway variables like `$left`, `$down`, `$up`, and `$right`, is dynamically handled according to their definitions within the file. The commands are then returned as a single string, with each bindsym command on a new line, sorted alphabetically.

This function is particularly useful for users of the Sway Window Manager who wish to quickly audit their keybindings associated with the mod key — a common requirement for optimizing workflow efficiency or for documentation purposes.

Parameters

`PATH`: Path to the SwayWM configuration file to be parsed.

Usage

To use `swaywm-list-mod-bindsyms`, call the function with the path to your SwayWM configuration file as its argument. For interactive use:

M-x swaywm-list-mod-bindsyms

When prompted, enter the full path to your SwayWM configuration file. The output will be shown, depending on the Emacs settings, either directly in the minibuffer (for shorter lists) or in a separate buffer for longer outputs.

Example

Assuming there’s a SwayWM configuration file located at `~/sway/config`, you would use the function as follows:

M-x swaywm-list-mod-bindsyms RET ~/sway/config RET

The returned value will be a sorted list of all `bindsym` commands associated with the `$mod` key or its resolved value (e.g., `Mod4`) from the file, neatly formatted for easy inspection.

Notes

This function assumes a standard formatting of the SwayWM configuration file, as deviations might affect the parsing logic.
The sorting is done in a case-sensitive alphabetical order, following Emacs’ `string-lessp` function conventions.
All modifications to variables like `$mod`, `$left`, `$down`, `$up`, and `$right` are dynamically accounted for based on their set values in the configuration file.

Emacs Vim Navigation Without Evil

James Dyer — Sat, 11 May 2024 21:40:00 +0100

Every now and then I find it necessary to use Vim! (mainly for work) - was that clickbait on an Emacs blog?! 😀

!pragma layout smetana
hide footbox
box "Emacs Vim Navigation Without Evil" #lightblue
h -> j
j -> k
k -> l
end box

Introduction

I therefore like to have the muscle memory for basic Vim navigation keybindings already built up as that for me is half the battle when using Vim and I also appreciate the efficiency and natural feel of the navigation keybindings `hjkl`.

In light of this I have decided to incorporate this Vim navigation paradigm into Emacs. My muscle memory is already fully baked and attuned to the Emacs default navigation keys so why not learn something new? with the benefits of an already oven warm familiar feel if I do have to use Vim and maybe anything else that might support vim keybindings (which is not uncommon), for example pacseek and seemingly most browser key navigation add-ons.

Of course before delving a little further I shall have to talk about the herd of elephants in the room… and that is the current plethora of Emacs modal editing packages, such as `evil-mode`, `Meow` et al. They have been developed to bridge the modal gap, for example, `evil-mode` is a comprehensive emulation layer that replicates Vim’s keybindings and modes, offering Vim users a more familiar experience within Emacs. On the other hand, `Meow` presents a more streamlined approach, designed with simplicity in mind, aiming to provide the efficiency of modal editing without mirroring Vim’s functionality in its entirety.

Despite the advantages of these packages, I wanted to find a method that involves neither the full adoptation of `evil-mode` nor the simplified modal editing of `Meow` or anything similar. My goal here is to utilize Vim’s `hjkl` navigation keys within Emacs in a non-modal context, thereby retaining Emacs’s modeless editing advantages while enjoying the familiarity and comfort of Vim’s navigation system.

To achieve this, I tapped into the power of Emacs’s keybinding customization capabilities.

Simply, I reassigned the original Emacs functions defined by `M-hjkl`. This allows a Vim-style navigation in Emacs’s default mode-less environment using the following keybindings:

(bind-key* (kbd "M-h") #'backward-char)
(bind-key* (kbd "M-j") #'next-line)
(bind-key* (kbd "M-k") #'previous-line)
(bind-key* (kbd "M-l") #'forward-char)

The original functions bound to these keys were seldom used in my workflow so I didn’t mind replacing them:

`M-h` (`mark-paragraph`) found a new home at `M-s h`.
`M-j` (`default-indent-new-line`), which I rarely used, was easily replaced by simply using `tab` or `C-i`.
`M-k` (`kill-sentence`), another feature I never utilized, was made redundant by the use of `kill-line`.
`M-l` (`downcase-word`), also rarely used, didn’t find a new binding as it wasn’t needed in my daily tasks.

The only disadvantage is that it requires holding down the Meta (or Alt) key with my left hand, but ergonomically that doesn’t seem too bad as that will be the only requirement for my left hand as my right will be busy with the navigation.

Conclusion

While `evil-mode` and `Meow` offer powerful modal editing solutions that closely mimic or simplify Vim’s interface within Emacs, my approach demonstrates an alternative path. By creatively reassigning keybindings, I have integrated Vim’s efficient navigation into Emacs without adopting a modal editing framework, blending the best of both worlds to enhance my text editing efficiency. This approach underscores the adaptability of Emacs, proving it to be an incredibly versatile tool that can accommodate a wide range of user preferences and workflows.

How To Map RAlt to Ctrl for Emacs

James Dyer — Sat, 04 May 2024 15:30:00 +0100

In a recent post I was talking about the benefits of mapping the RAlt key to the Ctrl key and this set up is so far still feeling very comfortable.

However, there are many ways to set up the mapping, so below are instructions on how to map the right Alt key (RAlt) to Ctrl for different platforms. These are just the methods I have used in the past, I’m sure there are a multitude of other options out there.

Before you dive in, here is a rough plantuml diagram to give you a top level diagrammatical overview of what I am describing below (note: kmonad is not included):

!pragma layout smetana
title: How To Map Ralt to Ctrl Activity Diagram
start
:Start;
if (OS == "Linux") then (yes)
if (Environment == "X11 or Wayland") then (yes)
:Generate xkb file;
note right
xkbcomp $DISPLAY -xkb keymap.xkb
end note
:Modify keymap.xkb;
note right
Add modifier_map and key definitions
end note
:Load modified file;
note right
xkbcomp keymap.xkb $DISPLAY
end note
:For persistence,\nadd to startup applications or\n.bashrc/.profile;
endif
if (Environment == "X11") then (yes)
:Choose Tool;
if (Tool == "xmodmap") then (yes)
:Create/Edit .Xmodmap;
:Add keycode modification;
:Apply changes;
note right
xmodmap ~/.Xmodmap
end note
else (no)
:Run setxkbmap command;
note right
setxkbmap -option ctrl:ralt_rctrl
end note
endif
:For persistence,\nadd to startup applications or\n.bashrc/.profile;
endif
if (Environment == "Wayland TWM") then (yes)
:Modify sway/hyprland config;
note right
Depending on the window manager, apply the necessary `input` configurations.
end note
:For persistence, ensure\nconfig is loaded on login;
endif
else (no)
:Install AutoHotkey;
:Create and Edit Script;
:Run Script;
note right
Script contains key remappings like RAlt::Ctrl
end note
:For persistence, place in "Startup" folder;
endif
stop

Linux

X11 or Wayland

xkb (X Keyboard Extension)

First generate an xkb file which defines all keybindings for the current layout by running the follwing command:

xkbcomp $DISPLAY -xkb keymap.xkb

Add to the keymap.xkb file along with the other defined modifier_maps:

modifier_map Mod1 { <RALT> };

and set the definition of key to:

key <RALT> { [ Alt_L, Meta_L ] };

Now load the modified file back in again:

xkbcomp keymap.xkb $DISPLAY

If you want it to be applied every time you log in, you can add this command to your startup applications or add it to your .bashrc or .profile file.

X11 only

xmodmap

Xmodmap is a little archaic these days and is seen as being a little deprecated and soon to become obsolete (especially with the incoming Wayland protocol) but especially on X11 it can still be used if you don’t want to fiddle around with xkb files.

To map the right Alt key (RAlt) to Ctrl using xmodmap in Linux, you can follow these steps:

Create a file named .Xmodmap in your home directory if it doesn’t exist already.

Add the following line to the file:

keycode <keycode_of_RAlt> = Control_L

Replace with the keycode of your right Alt key.

To find the keycode, you can use the xev command. Open a terminal and run:

xev

This will open a small window. Move your cursor into that window and press the right Alt key. Look for the keycode in the terminal output. It should look something like keycode 108 (maybe exactly like!)

To apply the changes, run:

xmodmap ~/.Xmodmap

Now your right Alt key should behave like the Ctrl key. Keep in mind that this mapping will only persist for your current session. If you want it to be applied every time you log in, you can add the xmodmap ~/.Xmodmap command to your startup applications or add it to your .bashrc or .profile file.

setxkbmap

Simply run the following command:

setxkbmap -option ctrl:ralt_rctrl

If you want it to be applied every time you log in, you can add this command to your startup applications or add it to your .bashrc or .profile file.

Wayland Tiling Window Managers

Sway

Perform the xkb steps defined above and then modify the sway config file as follows:

input type:keyboard {
 xkb_file keymap.xkb
}

alternatively modify the sway config file as follow:

input type:keyboard {
 xkb_options ctrl:ralt_rctrl
}

As this is modifying the basic config file it will be guaranteed to be loaded every time you log in.

Hyprland

As the xkb steps above and then modify the hyprland config file as follows:

input {
 kb_file = keymap.xkb
}

alternatively modify the hyprland config file as follow:

input {
 kb_options = caps:ctrl_modifier
}

As this is modifying the basic config file it will be guaranteed to be loaded every time you log in.

Windows

AutoHotKey

Install AutoHotkey if you haven’t already. You can download it from the official website: https://www.autohotkey.com/

Once AutoHotkey is installed, right-click on your desktop or in a folder, hover over “New,” and select “AutoHotkey Script.” Name the script whatever you like, for example, RAlt_to_Ctrl.ahk.

Right-click the newly created script file and select “Edit Script” to open it in your default text editor.

Add the following line to the script:

RAlt::Ctrl

Save the script and close the text editor.

Double-click the script file to run it. You should see a green “H” icon in the system tray indicating that the script is running.

Now, whenever you press the right Alt key, it will function as the Ctrl key. To stop the remapping, right-click the AutoHotkey icon in the system tray and select “Exit.”

This remapping will persist until you close the script or disable AutoHotkey. If you want the remapping to be applied automatically every time you start your computer, you can place a shortcut to the script in the “Startup” folder of your Start Menu.

Linux or Windows

kmonad

Install kmonad if you haven’t already. You can find installation instructions on the GitHub repository: https://github.com/kmonad/kmonad

Once kmonad is installed, create a configuration file called kmonad.hs

linux

Add the following lines :

(defcfg
 input (device-file "/dev/input/by-path/<device>")
 output (uinput-sink "My KMonad output")

 ;; Comment this if you want unhandled events not to be emitted
 fallthrough true

 ;; Set this to false to disable any command-execution in KMonad
 allow-cmd true
 )

(defsrc ralt)

(deflayer default lctrl)

Now on the command line run up:

kmonad kmonad.hs

To ensure that the mapping persists place the command to your startup applications or add it to your .bashrc or .profile file.

windows

(defcfg
 input (low-level-hook)
 output (send-event-sink)
 fallthrough true)

(defsrc ralt)

(deflayer default lctrl)

Now create a batch script called kmonad.bat and add:

kmonad.exe kmonad.hs

This remapping will persist until you close kmonad.exe. If you want the remapping to be applied automatically every time you start your computer, you can place a shortcut to the script in the “Startup” folder of your Start Menu.

This post may end up turning into some kind of living document when I find out other ways to perform the mapping, for example I might start to look at Kanata and also see if PowerToys can perform this mapping on Windows.

My Emacs Key Workflow Moments Over The Last 30 Years

James Dyer — Fri, 26 Apr 2024 15:00:00 +0100

I am just at the moment reflecting on how my experience with Emacs over the last 30 years has evolved. I thought that just for fun I would list all the key moments along my Emacs journey regarding work-flow efficiency breakthroughs, roughly in year order!.

I think you can see that my investment of time has spiked in recent years, probably spurred on by writing this blog!

Firstly I went through the barren years… :

!pragma layout smetana
!theme mars
skinparam backgroundColor #eeeeee
skinparam sequenceArrowThickness 1
skinparam DefaultFontSize 20
skinparam roundcorner 20
hide footbox
-> 1994 : learning emacs at University
-> 2000 : mapped caps lock to ctrl
-> 2002 : desktop save mode
-> 2010 : using dired to replace native file explorer
-> 2016 : elisp defuns for common tasks
-> 2016 : savehist-mode
-> 2016 : winner mode
-> 2017 : ivy
-> 2018 : dabbrev
-> 2019 : rebinding keys to match usage frequency
-> 2019 : imenu for navigation
-> 2019 : macros for repetitive tasks

and then when I started to get a little more serious about Emacs :

!pragma layout smetana
!theme mars
skinparam backgroundColor #eeeeee
skinparam sequenceArrowThickness 1
skinparam DefaultFontSize 20
skinparam roundcorner 20
hide footbox
-> 2021 : grep with deadgrep
-> 2021 : magit
-> 2021 : leader key definition M-<key> - to take load off ctrl
-> 2021 : hippie expand
-> 2022 : vertico, orderless, marginalia
-> 2022 : embark for quick actions
-> 2023 : tempel - unique 2 characters to insert common templates
-> 2023 : vim cursor movement (without evil) - so fingers remain on home row
-> 2023 : moving to tabs to switch between windows setups
-> 2023 : tab bar history
-> 2024 : sticky keys - single key presses, no key chording
-> 2024 : using a mechanical keyboard
-> 2024 : mapped ralt to ctrl - to take complete load off even the caps lock remapping
-> 2024 : capf-autosuggest in [e]shell to get a more fish like experience
-> 2024 : org mode speed keys - single key presses for common org commands

Note that I have endeavoured to incorporate some level of completion framework into my work-flow, systems such as company and corfu but I always end up just using hippie-expand wrapped around dabbrev.

I think this is why I have always been drawn to Emacs, it is just me and a text editor, there is no clutter and no distractions, although there is so much more to Emacs than just a text editor, everything else is hidden away. I don’t really want inline completion popups as I type, I don’t need a menu bar, scroll bars, a source code tree and I tend to always work on a single monitor so the saving on screen real estate is very beneficial to the way I work.

I am a Software Engineer now of 30 years, I am stuck in my ways, stuck with Emacs, but I am happy, productive and efficient!

P.S. and yes I’m starting to play around with plantuml 🙂

Transitioning RAlt to Ctrl - Enhancing Emacs Keybindings

James Dyer — Sat, 20 Apr 2024 10:12:00 +0100

In the midst of adjusting my Emacs keybindings for a more ergonomic workflow, I’ve experimented with various configurations. For example, I duplicated the right Alt key (RAlt) to function as an additional Alt key allowing for versatile key presses across the keyboard based on command keybinding locations.

The RAlt key is certainly accessible with a little curl under of the right thumb and a modifier key activator I hadn’t even considered before.

For instance, I found combinations like M-n and M-p already comfortable with a left hand / right hand split, but with RAlt for activating Meta/Alt a right hand / left hand split became possible for certain commands, notably M-f and M-w which I often use. This theoretically already felt a more comfortable setup.

However, after a few months, I realized I couldn’t quite find a way to transition to the RAlt remapping; I simply wasn’t using it. Yet, the initial experiment hinted at the potential of shifting modifier load to the right hand, especially leveraging the strong thumb for ergonomic advantages.

Then it struck me: what if I map RAlt to Ctrl?, I immediately questioned why I hadn’t tried it earlier!

The transition so far has unveiled the following (note: I may have got carried away with the detail here, but in a way its fun to weigh up the pros and cons!):

Benefits

Splitting common prefixes like C-x and C-c between hands.
Enhanced comfort in isearch with split hand C-r and C-s.
Improved buffer window navigation, with RLR (Right Left Right) pattern for C-x o.
Simplified buffer window splits with C-x <num>. Although there are typically two consecutive left hand key activations, sticky keys allows just two individual key taps of x then <num>.
Streamlined actions like the common C-c C-c, with the option of holding RAlt allowing easy left-hand tapping of c, c
Reassigned C-o (never used) to the (other-window) so I can replace my ever fluctuating window keybinding navigation to something more simple using just one hand, plus I can hold down the Ralt and tap through the windows.
C-g was always a bit of stretch - especially before sticky keys, but now I have a RL combination.
Simplified Emacs exit with C-x C-c (although why would I ever need this?!) holding RAlt for x,c tap tap.
A locked sticky key Ctrl double tap now doesn’t activate a double whammy of left hand pinky lateral movement.
Saving can be easier, C-x C-s again is a right hand modifier hold with an x,s tap
Another common command (which in fact I had to rebind as it was too taxing on my left hand) is now much more comfortable, namely C-x C-e (eval-last-sexp) in the same way as saving mentioned above.
I am finding myself instinctively using C-j a lot more as naturally my right thumb is now very close to RAlt and my right index finger is always on j
Reverting buffers is much easier, It is bound to C-x x g (revert-buffer-quick)
I am finding myself starting to revert back to the vanilla Emacs keybindings rather than my adapted ones mainly I suspect that C-x and C-c is much easier now to access.

Negatives

I will have to adjust to the new position of the keybindings, and some like the undo with C-/ feed a bit strange due to the close proximity between Ralt and /
Keyboard configuration is required to map Ralt to Control.

I’ll evaluate this setup’s efficacy over the next few months and I may contemplate not just the possibility of minimizing Ctrl key usage on the left hand but potentially eliminating it altogether! My left hand pinky would then never have to attempt lateral movement again!

Waybar Toggling Sticky Key Keymaps

James Dyer — Sun, 14 Apr 2024 11:55:00 +0100

For my previous post I was talking about a software visual indicator to discern which key has been locked in a sticky key situation. For example there are typically two modes of stickiness, being latched and locked, by default I had set up the locked variant as I thought it would be more useful for Emacs and in fact I have found this to be the case. For example, double tapping the Control key allows nice easy single key navigation via ’n’ ‘p’ ‘f’ and ‘b’, possible page down with ‘v’ and to delete lines I can use ‘k’ .e.t.c.

I’m sure I will find more bonuses in Emacs with this key locking mechanism and of course I can always tweak my keybindings, for example maybe a page up could be a Ctrl-<key> so I can have even more power navigating with a single <key>.

But how does a locked key setup work in a different program? and especially the software I use for my digital art, namely Krita. I have a USB numpad peripheral in which I map each key to a Krita shortcut, for example common actions such as colour picking, brush resize, canvas flip, undo / redo e.t.c. I have found this to actually be a nice cheaper option than one of the more specialised digital art controllers and more flexible as I will always be able to use it on linux with keymapping software like kmonad or kanata.

It didn’t take long to find out that I was running into difficulties with Krita and the locked sticky setup. For example colour picking is quite a common activity in digital art and it just so happens that for Krita it is bound by default to the Ctrl key! In addition Shift resizes the brush too. I found that quite often I was tapping the Ctrl and or Shift consecutively which was locking the modifier key which would have some unwanted side effects and would start to get frustrating as I fumble around to unlock the relevant modifier thus disrupting my flow. I quickly came to the conclusion that a locked sticky was not viable for my use within Krita.

So how could I craft a solution to this problem?

In my previous post, I might have unintentionally already laid the groundwork as I have created both a latched and a locked sticky key variant in the xkb file format. Perhaps I could develop a toggling mechanism between the locked and latched states, switching to latched state when I use Krita.

Just like before, I think Waybar would be ideal to perform the toggle with a click (which could also be a stylus click from a pen) and to then display the current status.

Initially I created the following bash script to perform the toggling of the keymaps :

#!/bin/bash

# Define the paths to your keymap files
KEYMAP_SWAY=~/.config/keymap_sway.xkb
KEYMAP_LOCKED=~/.config/keymap_with_locked_modifiers.xkb
KEYMAP_STICKY=~/.config/keymap_with_sticky_modifiers.xkb
CURRENT_KEYMAP_PATH=~/.config/keymap_current

# Check if the current keymap is set, if not use the sway keymap
if [[ ! -f "$CURRENT_KEYMAP_PATH" ]]; then
 echo "$KEYMAP_SWAY" > "$CURRENT_KEYMAP_PATH"
fi

CURRENT_KEYMAP=$(cat "$CURRENT_KEYMAP_PATH")

# Swap the keymaps
if [[ "$CURRENT_KEYMAP" = "$KEYMAP_LOCKED" ]]; then
 cp -f "$KEYMAP_STICKY" "$KEYMAP_SWAY"
 echo "$KEYMAP_STICKY" > "$CURRENT_KEYMAP_PATH"
else
 cp -f "$KEYMAP_LOCKED" "$KEYMAP_SWAY"
 echo "$KEYMAP_LOCKED" > "$CURRENT_KEYMAP_PATH"
fi

# Reload Sway configuration
swaymsg reload

Note that at first I tried to use the xkbcomp command but by all accounts only works on X11 so with wayland and in particular Sway I had to find a workaround to reload a toggled keymap - which is where swaymsg reload comes in. The solution is a little hacky but will work and involves swapping around files on disk and then forcing a reload of the sway configuration file.

As always with toggling, the key is usually working out the current toggle state in order to know what to toggle to. I decided to use the old fashioned method of a file on disk containing the path to the current keymap!

In the sway configuration file I can now attach a keybinding to the new toggle script :

bindsym $mod+y exec keymap-toggle.sh

‘y’ for sticky seems appropriate methinks.

Now for updating waybar to reflect the status. In this case as in the modifier LEDs of my last post I will have to create some custom modules and link it to a content producing bash script.

A keymap_monitor.sh script is as follows:

#!/bin/bash

CURRENT_KEYMAP_PATH=~/.config/keymap_current

CURRENT_KEYMAP=$(cat "$CURRENT_KEYMAP_PATH" | grep "sticky")

if [[ $CURRENT_KEYMAP ]]; then
 echo "{\"text\": \"STICKY\", \"class\": \"active\"}"
else
 echo "{\"text\": \"LOCKED\", \"class\": \"inactive\"}"
fi

and the waybar module :

 "custom/togglesticky": {
"exec": "keymap-monitor.sh",
"interval": 1,
"return-type": "json",
"on-click": "keymap-toggle.sh",
}

Note the return-type type is json and the echo statements in the keymap_monitor.sh script have formatted the return data in the json format meaning the waybar module can process the string effectively. Note also a css class is set up which will link to the associated waybar css style sheet and potentially offer a nice flexible look for each mode if desired.

“on-click”: “keymap-toggle.sh” will allow the toggle to be actioned and the monitor script will be called every second as per the interval setting to poll the current toggle state.

Well that should be about it!, when I now open up Krita I can just tap on the LOCKED indicator on waybar which will then display STICKY (I decided to go with STICKY rather than LATCHED) This now indicates that I have changed the keymap, at which point double tapping any modifier keys as part of my arting shenanigans will now not lock the associated modifier and cause annoyance down the line.

I might even eventually find some icons or my preferred method emojis to make things look more graphically pleasing, but with all these things I always initially look to get most of the way there and in a working state before I start polishing it.

Waybar Sticky Key LED indicators on a Laptop

James Dyer — Sat, 30 Mar 2024 16:43:00 +0000

From my previous post regarding setting up sticky keys mainly for Control, Alt and Shift in Emacs to remove the dependence on key chording I just wanted to scratch another itch, and that was to provide a modifier LED indicator type experience on a laptop that you would commonly get on a full size keyboard.

For example most laptops typically have a single LED indicator on the Caps Lock key with a full size keyboard having Num Lock, Caps Lock and Scroll Lock specific LEDs and generally in that order.

How would I accomplish this more granular display on a laptop that only has a single Caps Lock indicator LED?.

My previous solution of activating the Caps Lock LED when any modifier was activated works to an extent. However, you still don’t know which specific modifier is active, so to clear a locked modifier you might still have to go hunting around the modifiers to find out which one has been activated.

This so far is the only negative I have found using Sticky Keys in that occasionally a modifier key becomes accidentally locked (I suppose stuck!) and it takes a while to figure out which one.

In a highly configurable environment like Sway where you pretty much have to build most things for yourself the flexibility offered can allow me to craft a software solution by modifying the bar to visually indicate the current locked modifiers. So when stickies get stuck a quick glance will tell you which modifiers are active and hence which ones to deactivate.

For now I will just focus on waybar which is a customizable bar for Wayland compositors although setting up something like Polybar for X11 would be very similar.

I think the way to achieve this is to figure out how to access the current state of LED indicators which signify which sticky modifiers are set. Currently any modifier on my laptop activates the Caps Lock LED indicator and although specifically a hardware LED, each modifier can be stored separately, and through xkb (X Keyboard Extension) we can store each LED state in the following locations if set up correctly:

/sys/class/leds/input2::capslock
/sys/class/leds/input2::numlock
/sys/class/leds/input2::scrolllock

My first step is to split the modifiers, setting each internal device accordingly in /sys/class/leds, so the original xkb file will change from:

indicator "Caps Lock" {
!allowExplicit;
whichModState= locked;
modifiers= Control+Mod1+Shift;
};

indicator "Caps Lock" {
!allowExplicit;
whichModState= locked;
modifiers= Control;
};
indicator "Num Lock" {
!allowExplicit;
whichModState= locked;
modifiers= Mod1;
};
indicator "Scroll Lock" {
whichModState= locked;
modifiers= Shift;
};

which is the way I would activate each LED for a full size keyboard.

Next is to access each LED value so I can pass it through to waybar for display. I will have to access the LED states more directly, hence in linux pulling values straight from a directory called /sys/class/leds

The following bash script will pass out a JSON formatted string which waybar will be able to process in a custom module:

#!/bin/bash

# Define the paths to the LED brightness indicators
caps_lock_led="/sys/class/leds/input2::capslock/brightness"
num_lock_led="/sys/class/leds/input2::numlock/brightness"
scroll_lock_led="/sys/class/leds/input2::scrolllock/brightness"

# Function to output the JSON format for Waybar
output_json() {
 local text="$1"
 local active="$2"
 if [ "$active" = "1" ]; then
 echo "{\"text\": \"$text\", \"class\": \"active\"}"
 else
 echo "{\"text\": \"$text\", \"class\": \"inactive\"}"
 fi
}

# Check the command-line argument and output the respective LED status
case "$1" in
 --caps)
 caps_state=$(cat "$caps_lock_led")
 output_json "Ctl" "$caps_state"
 ;;
 --num)
 num_state=$(cat "$num_lock_led")
 output_json "Alt" "$num_state"
 ;;
 --scroll)
 scroll_state=$(cat "$scroll_lock_led")
 output_json "Sft" "$scroll_state"
 ;;
 *)
 echo "Usage: $0 [--caps | --num | --scroll]"
 exit 1
 ;;
esac

Each LED is associated with its own device, and conveniently, the brightness file is simply a text file containing either a 0 or 1 to indicate whether the LED is active or inactive. To facilitate integration with custom modules in Waybar, and to link them into its CSS I will need to output each module as JSON, assigning each key modifier a class set to either ‘active’ or ‘inactive’.

I will have to write a some custom waybar modules so in the associated modules.json :

 "custom/caps_lock": {
"exec": "led-monitor.sh --caps",
"interval": 1,
"return-type": "json"
},
"custom/num_lock": {
"exec": "led-monitor.sh --num",
"interval": 1,
"return-type": "json"
},
"custom/scroll_lock": {
"exec": "led-monitor.sh --scroll",
"interval": 1,
"return-type": "json"
}

Each button has to be a separate module with each having its own name and LED state which enables the CSS to access each LED individually.

I have kept the styling simple for now but of course the style can be anything you like, so here is an associated CSS :


/* General LED styling */
#custom-caps_lock,
#custom-num_lock,
#custom-scroll_lock {
 padding: 0em 0.2em;
}

/* Active LED styling */
#custom-caps_lock.active,
#custom-num_lock.active,
#custom-scroll_lock.active {
 background-color: @recording-color;
}

Here I have put a general padding on the right and left and then defined a simple highlight background colour for when the JSON script above returns active.

These modules can be positioned anywhere along waybar, I typically like to have mine on the right as thus :

with modifier activation of Alt and Shift shown as:

So in the case above if my keys are doing weird things I can quickly glance at waybar and see that Alt and Shift are currently Sticky activated thus I can deactivate by selecting each to remove the visual indicators and carry on my merry little way!

Eliminating Key Chords in Emacs under Linux with Sticky Keys

James Dyer — Fri, 22 Mar 2024 21:39:00 +0000

I spend many hours living in emacs and a large proportion of this time is using a laptop. Recently I have been thinking about my hands and how to protect them from any future pain or RSI.

Emacs out of the box can be a little, lets say ~~tortuous~~ awkward. For example I’ve always found the default keybindings for switching windows (`C-x o`) and saving buffers (`C-x C-s`) to be particularly uncomfortable, a feeling exacerbated by their frequent use. Also, key presses in Emacs typically involve key chording, this means that not only do you have to contort your hand into awkward positions, but you also have to press keys simultaneously thus reducing the possibility for natural hand movement during key activation.

The concept of C-x, especially for a Control key not mapped to the Caps Lock can really take its toll over a number of years; as of yet I am fortunate not to have yet experienced any hand pain but from what I’ve read, it’s not uncommon for discomfort to start to set in after many years of daily keyboard use, so I really want to take measures now.

In a previous post I had started to discuss this topic :

Sticky Keys on Sway using kmonad

I attempted to use the cross platform tool kmonad to apply Sticky Key functionality thus obviating the need for multiple key chord activation in emacs. For the most part a basic latched sticky concept works well and is easy to set up, however when using emacs I think a locking sticky modifier would be a much better fit, which is where a modifier will be locked on a double tap and then unlocked with a single tap.

For instance, if I could lock the Control key, navigating a buffer could be done with single key presses using ’n’, ‘p’, ‘b’, and ‘f’. Deleting multiple lines, a task I frequently do, would then require only individual presses of the ‘k’ key. To mark a selection, I could simply tap the space-bar and then use single navigation keys to expand the selection. A single tap of the Control key would then deactivate the lock.

Unfortunately kmonad doesn’t yet support this kind of sticky key locking functionality, however my attempts at finding a workaround led me to stumble into the murky arcane world of the x keyboard extension!

An XKB (X Keyboard Extension) file format is essentially a descriptive language that allows you to define the behaviour of the keyboard on linux. This includes the mapping of physical keys to symbols (characters or functions), modifying the action of keys depending on other keys that are held down (modifiers like Shift, Ctrl, Alt) and was primarily developed for the X11 windowing system.

I run a Wayland compositor called Sway as my daily driver and it just so happens that Wayland is compatible with the x keyboard extension standard!

Below are some instructions on how to set up Sway with Sticky keys to help eliminate the need for key chords in emacs. These instructions have been applied to the Sticky Keys section in the emacs wiki : https://www.emacswiki.org/emacs/StickyModifiers#h5o-8

Note that the following instructions can also work for X11 desktop environments as the x keyboard extension has been the de facto standard for many years on X11 and in fact I have successfully set up Sticky Keys in the same manner for the i3 window manager.

Setting up Sticky Keys through XKB

Firstly run the bash script below to create two sticky keyboard variant files:

#!/bin/bash
DST=$HOME/.config

# Reset keyboard layout (to your preferred language)
setxkbmap gb

# Apply sticky modifiers to a file
xkbcomp $DISPLAY -xkb - | \
 sed 's|SetMods|LatchMods|g' > \
 $DST/keymap_with_sticky_modifiers.xkb

# Reset keyboard layout (to your preferred language)
setxkbmap gb

# Apply locked modifiers to a file
xkbcomp $DISPLAY -xkb - | \
 sed 's|SetMods|LatchMods|g' | \
 sed 's|,clearLocks);|,clearLocks,latchToLock);|g' > \
 $DST/keymap_with_locked_modifiers.xkb

keymap_with_sticky_modifiers.xkb - a latched sticky modifier setup in which a modifier is activated by a following key press.
keymap_with_locked_modifiers.xkb - a locking sticky modifier setup in which a modifier will be locked on a double tap and then unlocked with a single tap.

At this point you can activate Sticky Keys by loading the new xkb keymap in the Sway config as follows:

input "type:keyboard" {
xkb_file $HOME/.config/keymap_with_locked_modifiers.xkb
}

Note that for X11 you can use the xkbcomp command as thus:

xkbcomp $HOME/.config/keymap_with_locked_modifiers.xkb $DISPLAY

Optionally modify the xkb file directly after generation to use the “Caps Lock” keyboard indicator LED for indicating a sticky modifier is active, like so :

indicator "Caps Lock" {
!allowExplicit;
whichModState= locked;
modifiers= Control+Mod1+Shift;
};

This turns on the Caps Lock LED whenever a Control, Alt (Mod1) or Shift key is sticky locked giving a visual hint to any locked keys. Although useful on a laptop if you are using a full sized keyboard each modifier can be linked to its own indicator LED, for example:

indicator "Caps Lock" {
!allowExplicit;
whichModState= locked;
modifiers= Control;
};
indicator "Num Lock" {
!allowExplicit;
whichModState= locked;
modifiers= Mod1;
};
indicator "Scroll Lock" {
whichModState= locked;
modifiers= Shift;
};

As part of this keyboard redefinition it might also be useful to remap the Caps Lock key to the Control modifier. One way to achieve this in Sway is to modify the config file as follows:

input type:keyboard {
xkb_file $HOME/.config/keymap_with_locked_modifiers.xkb
xkb_options ctrl:nocaps
}

However, as we are redefining our keyboard layout we can directly modify the xkb configuration file in the following manner:

replace:

 key <CAPS> { [ Caps_Lock ] };

with

 key <CAPS> { [ Control_L ] };

replace:

 modifier_map Lock { <CAPS> };

with

 modifier_map Control { <CAPS> };

For bonus points, and to ensure that the right Alt modifier functions like a regular Alt thereby distributing the keys more evenly between the left and right hands, perform the following changes:

add:

 modifier_map Mod1 { <RALT> };

set the definition of key <RALT> to:

 key <RALT> { [ Alt_L, Meta_L ] };

With this setup, I can now effectively press single keys in succession to trigger functionalities in Emacs that would normally require key chording. Even pressing C-g has become naturally easier; I’m now pressing Ctrl, then not having to stretch my index finger across at the same time as my pinky is now released from the control key.

My Dotfile

James Dyer — Thu, 14 Mar 2024 16:28:00 +0000

Simply a link to my emacs literate config file 😀

kmonad Sticky Keys on Sway to Help Prevent RSI

James Dyer — Fri, 08 Mar 2024 20:48:00 +0000

I primarily use Emacs on a laptop, and unfortunately, Emacs isn’t inherently designed for ergonomic use. Coupled with the less-than-ideal typing experience of continuous laptop use, I’m considering adopting preemptive measures to protect my hands from potential strain injuries, including the infamous emacs pinky and RSI.

My awareness of this issue heightened after watching numerous informative coding videos by Xah Lee, from which I’ve gleaned valuable tips on making simple yet effective adjustments to safeguard my hands.

One recommended strategy was relocating the Ctrl key to the Caps Lock position, a common suggestion that I had already implemented a few years ago. Another was to use a mechanical or ergonomic keyboard, which I have not considered feasible for my needs as I have a strong preference for using a laptop, particularly for its versatility as a digital art tablet with a 2-in-1 design.

Nonetheless, there’s another solution within my reach: Sticky Keys. Although I’ve been predominantly aware of Sticky Keys through the inconvenient pop-up in Windows triggered by prolonged keypresses, Xah Lee’s insights shed light on its potential benefits in alleviating the strain caused by emacs’ key chord demands. My only concern is that my preferred Linux window manager, Sway, lacks built-in support for Sticky Keys, unlike Gnome and KDE.

Fortunately, there is a tool I am already using right under my nose that I had overlooked and that is kmonad.

Just for clarification, Sticky Keys allow the user to perform key combinations by pressing keys in sequence rather than simultaneously hence splitting emacs key chords into individual keypresses.

Here is a little summary of what kmonad can do:

KMonad offers advanced customization features such as layers, multi-tap, tap-hold, and much more. These features are usually available at the hardware level on the QMK-firmware enabled keyboards. However, KMonad allows you to enjoy such features in virtually any keyboard by low-level system manipulations.

KMonad lets you map any keyboard button to any keymap. Want to swap the useless Caps Lock key with the Escape key? Want to have your modifiers such as Shift and Control on your home row, without breaking your normal typing flow? Want a modifier that is combination of Alt + Ctrl + Super + Shift? You can do all of those and much more!

I am already using kmonad to map the caps lock key to ctrl but on reading the excellent tutorial file I realised that in the latest version, namely v0.4.2 <2023-10-07 Sat>, it included sticky-key functionality!

Here is a little kmonad documentation regarding sticky keys:

KMonad also supports so called “sticky keys”. These are keys that will behave as if they were pressed after just tapping them. This behaviour wears off after the next button is pressed, which makes them ideal for things like a quick control or shift. For example, tapping a sticky and then pressing `abc’ will result in `Abc’.

You can create these keys with the `sticky-key’ keyword:

(defalias slc (sticky-key 500 lctl))

The number after `sticky-key’ is the timeout you want, in milliseconds. If a key is tapped and that time has passed, it won’t act like it’s pressed down when we receive the next keypress.

It is also possible to combine sticky keys. For example, to get a sticky shift+control you can do

(defalias ssc (around (sticky-key 500 lsft) (sticky-key 500 lctl)))

The Sway kmonad configuration below will activate a sticky key for all my linux modifier keys along with mapping the caps lock to the ctrl key:

(defcfg
input (device-file "/dev/input/by-path/platform-i8042-serio-0-event-kbd")
output (uinput-sink "My KMonad output")
;; Comment this if you want unhandled events not to be emitted
fallthrough true
;; Set this to false to disable any command-execution in KMonad
allow-cmd true
)
(defsrc caps lctl lsft rsft lalt ralt lmet)
(deflayer mine
(sticky-key 2000 lctl)
(sticky-key 2000 lctl)
(sticky-key 2000 lsft)
(sticky-key 2000 rsft)
(sticky-key 2000 lalt)
scrlck
(sticky-key 2000 lmet))

For us emacs types the configuration file also looks a bit lispy! 😀

Kmonad is also cross platform so it will run on windows too and for my next post I’m going to look to replace my current Autohotkey setup in windows with kmonad and see if it works as well as it does in linux!

Unified Interface for Switching Contexts - Switch to Thing

James Dyer — Tue, 05 Mar 2024 17:56:00 +0000

Now I have ditched save-desktop for recentf which gives me a faster startup time but still being able to quickly access my most common files (i.e. those I have most recently opened) I have realised that I would like to have quick access to other Emacs resources after a startup.

This has led me to creating a unified interface of sorts to switch to different contexts through a single keybinding. If you think that sounds vague, well you are correct!, I shall try and explain myself.

save-desktop has served me well for many many years as a quick method to call up my last session including recreating buffers in their last positions and thus repopulating the ibuffer list and re-enabling the default Emacs switch-to-buffer mechanism.

Unfortunately as I am now fiddling around with elisp it means that restarting Emacs has become much more commonplace and I don’t really want to wait around for save-desktop to recreate itself after each reload. In addition there were the odd peculiarities that I could never seem to resolve.

Out of the box recentf has its own basic opening mechanism not tied into anything particularly modern with a list of files populated for selection in a separate buffer, but consult-recent-file solves this by giving me a nice completing-read experience.

So now I can recall my most recent files in a nice completing-read way how about preserving a familiar switching experience, I could bind consult-recent-file to C-x b, hence switch-to-buffer for continuity, but then of course I can’t switch to buffer! should I have separate keybinding for consult-recent-file?, well maybe, but what else would I like to quickly switch to?

Well of course buffers! I shouldn’t get carried away without forgetting the Emacs staple switching mechanism and in fact switch-to-buffer is perfectly fine and is completing-read enabled (I could also use consult-buffer)

Bookmarks! (can I start a sentence like that?). This is a very underrated feature that I have become more accustomed to using and of course the USP being that a bookmark can reference a file, info page, directory, or pretty much anything you would want to access in Emacs. Well that has a separate selection mechanism too via bookmark-bmenu-list which displays a list of existing bookmarks in a separate buffer. Again the brilliant consult-bookmark comes to the rescue converting the bookmark mechanism into a completing-read, but how do I access this list?, another keybinding?, well maybe.

I am also one of those people that switches themes very often, like several times a day, well how do I do this?, load-theme, customize-themes?. Out of the box theme selecting has a separate selection mechanism too which displays a list of existing themes in a separate buffer. Again the brilliant consult-theme comes to the rescue giving a nice completing-read selection mechanism, but how do I access this list?, another keybinding?, well maybe.

So I have four contexts to switch to and I don’t want a single keybinding for each one so can I merge all of these contexts into a single completing-read under a single keybinding, with the completion mechanism of choice performing the heavy lifting to give me a fast unified method of quick switching? (and breathe! 😵‍💫), the answer of course is - “this is Emacs dummy, of course you can!”.

I thought this would also be a perfect opportunity to further my understanding of elisp by tackling this problem myself, which is how I came up with my/switch-to-thing, which is described below:

my/switch-to-thing

The provided Emacs Lisp function `my/switch-to-thing` offers a unified interface within Emacs to quickly switch contexts. It enables a user to perform one of several actions based on the user’s selection from a prompted completion list. The specific actions that can be taken are:

Switching to an Open Buffer: If the selection matches the name of an open buffer, the function switches the current window to display that buffer.
Opening a Recent File: If the selection matches an entry in the list of recently opened files, that file is opened in the current window.
Jumping to a Bookmark: If the selection matches a bookmark’s name, Emacs navigates to that bookmark.
Changing the Emacs Theme: If the selection starts with the prefix “Theme: “, the function interprets the rest of the selection as the name of a theme. It then loads and applies that theme.

Here is a break down of its behavior:

Initialization: It first creates lists of current buffer names (`buffers`), recent files (`recent-files`), bookmark names (`bookmarks`), and available themes formatted with a “Theme: " prefix (`themes`). These lists are then concatenated into `all-options`, forming a comprehensive list of choices for the user.
User Input: It prompts the user with a “`Switch to:`” message using `completing-read`, offering autocomplete functionality based on the `all-options` list. This prompt also integrates with Emacs’ `file-name-history` for enhanced usability.
Action Selection: Based on the user’s choice (`selection`), the function uses `pcase` to pattern-match and decide the action:
- If the selection is an open buffer, it switches to that buffer (`switch-to-buffer`).
- If the selection is a bookmark, it jumps to that bookmark (`bookmark-jump`).
- If the selection is prefixed with “Theme: “, it extracts the theme name, converts it back to a symbol, and loads that theme (`load-theme`).
- If none of the above conditions are met, it interprets the selection as a file path/name and attempts to open it (`find-file`).

This function effectively encapsulates multiple navigation and customization actions within Emacs into a single command, streamlining the user’s workflow by providing a centralized interface for common tasks.

(defun my/switch-to-thing ()
 "Switch to a buffer, open a recent file, jump to a bookmark, or change the theme from a unified interface."
 (interactive)
 (let* ((buffers (mapcar #'buffer-name (buffer-list)))
 (recent-files recentf-list)
 (bookmarks (bookmark-all-names))
 (themes (custom-available-themes))
 (all-options (append buffers recent-files bookmarks
 (mapcar (lambda (theme) (concat "Theme: " (symbol-name theme))) themes)))
 (selection (completing-read "Switch to: "
 (lambda (str pred action)
 (if (eq action 'metadata)
 '(metadata . ((category . file)))
 (complete-with-action action all-options str pred)))
 nil t nil 'file-name-history)))
 (pcase selection
 ((pred (lambda (sel) (member sel buffers))) (switch-to-buffer selection))
 ((pred (lambda (sel) (member sel bookmarks))) (bookmark-jump selection))
 ((pred (lambda (sel) (string-prefix-p "Theme: " sel)))
 (load-theme (intern (substring selection (length "Theme: "))) t))
 (_ (find-file selection)))))

selected-window-accent-mode now on MELPA

James Dyer — Fri, 09 Feb 2024 14:58:00 +0000

The selected-window-accent-mode is now present on MELPA and is my first Emacs package!

It is designed to visually distinguish the currently selected window by applying a unique accent color to its fringes, mode line, header line, and margins.

See https://github.com/captainflasmr/selected-window-accent-mode for more information and examples.

Whats New

Version 0.6.0

DONE ISSUE #1 Do not apply highlighting when frame only contains 1 window when selected-window-accent-smart-borders is set

DONE define accent color saturation adjustment

DONE define accent color darken adjustment

DONE highlight selected tab with same accent color

DONE add to MELPA

Quick Start

To use left and bottom accent based on the themes highlight colour:

(use-package selected-window-accent-mode
 :config (selected-window-accent-mode 1)
 :custom
 (selected-window-accent-fringe-thickness 10)
 (selected-window-accent-custom-color nil)
 (selected-window-accent-mode-style 'subtle))

OR define your own colour:

(use-package selected-window-accent-mode
 :config (selected-window-accent-mode 1)
 :custom
 (selected-window-accent-fringe-thickness 10)
 (selected-window-accent-custom-color "#427900")
 (selected-window-accent-mode-style 'subtle))

Alternative window highlighting packages

There exist a few Emacs packages that perform window highlighting but that don’t quite provide the feature set of selected-window-accent.

selected-window-accent focusses more on clearly but non-intrusively highlighting the currently selected/focussed window by highlighting aspects of the window border without having to modify the appearance of non-selected windows, hence more akin to a tiling window manager.

dimmer

“This package provides a minor mode that indicates which buffer is currently active by dimming the faces in the other buffers.”

This is the closest in functionality to selected-window-accent, the difference being that dimmer dims non selected windows rather than accent the selected window.

dimmer can be used in conjunction and will complement selected-window-accent to further enhance the emphasizing of the selected window.

hiwin

“This package provides a minor-mode to change the background colour of the non active window.”

It uses overlays to highlight non active windows, so is similar to dimmer but is less subtle in its highlighting mechanism and hasn’t been updated in excess of 10 years.

color-theme-buffer-local

“This package lets you set a color-theme on a per-buffer basis.”

Unlike dimmer and hiwin this package isn’t related to the concept of a selected window but more of defining different themes for different windows to distinguish them.

solaire-mode

“This package is designed to visually distinguish “real” buffers (i.e. file-visiting code buffers where you do most of your work) from “unreal” buffers (like popups, sidebars, log buffers, terminals, etc) by giving the latter a slightly different – often darker – background”

Unlike dimmer and hiwin this package isn’t related to the concept of a selected window but more of distinguishing between collections of IDE like elements within Emacs.

Roadmap / Improvements

TODO add darken desaturated and tab highlight examples to README

TODO define accent color hue adjustment

TODO define compensating margin

TODO Incorporate mode-line-active and mode-line-inactive somehow as this would make more sense especially in the ‘default mode.

TODO header-line not shown on window split - I have a funny feeling this could be very difficult, if not impossible!

TODO restore modeline height when switching between modes

TODO adjust the not selected-window margin to avoid little window navigation. disruption, hence translating a fringe pixel width to a number of margin characters, not quite sure how I am going to do this yet.

TODO excess selected-window disruption in header-line. (not sure I can do much about this)

TODO define which theme face attribute to use as the main accent color - Currently the default is to use the highlight face

WATCH possible overheads of updating visual elements for each window?

WATCH careful with removing header-line on all windows, for example magit commit window and probably some others may need to add some logic depending on mode.

Winner Undo to Tab Bar History

James Dyer — Sat, 03 Feb 2024 10:56:00 +0000

Now I am using the tab-bar workflow I noticed that winner-mode was not working per tab in that the winner undo would return to the previous state of another tab, pretty annoying! 😕

But there is an easy fix, replace (winner-mode 1) with (tab-bar-history-mode 1)

and for example I replaced my following keybindings:

(global-set-key (kbd "M-u") 'winner-undo)
(global-set-key (kbd "M-i") 'winner-redo)

with

(global-set-key (kbd "M-u") 'tab-bar-history-back)
(global-set-key (kbd "M-i") 'tab-bar-history-forward)

Ironically I had just been reading a related section in Mastering Emacs and this configuration was recommended to avoid confusion and general vexation.

I would also recommend increasing the number of tab bar history elements remembered, the default is 10 and I quickly found myself running out.

Therefore I put in:

(setq tab-bar-history-limit 100)

Opening Frequently Used Files More Efficiently using consult

James Dyer — Sat, 27 Jan 2024 21:14:00 +0000

Periodically, I find myself in situations where I restart Emacs frequently, such as when tweaking my configuration or simply experimenting. During these phases, to achieve a swift start-up, I often resorted to clearing my ibuffer as I tended to have more of an automatic desktop-save type workflow for restoring Emacs sessions. However this would leave me with the task of manually reconstructing my previous session by reopening files.

There are of course dired functions, like find-name-dired to more quickly locate files and although I have a good grasp of where my files are, this process became somewhat repetitive and time-consuming.

I realized that my sessions tend to involve the same set of files, sparking a need for a more streamlined approach.

This lead me to transition to the built-in recentf and then consult-recent-file with (setq recentf-max-saved-items 200) covering most of the files I would typically want to open.

Emacs starts up now in under 2 seconds and wont have a dependency on the number of buffers I had open on a previous session. If I want to edit a recent file I can open consult-recent-file bringing up a completing-read list of my recently opened files and because I have (savehist-mode 1) my very recently opened files will always appear at the top - quite handy!

The only aspect of consult-recent-file that I am not too keen on as with most consult functions is the file preview when traversing through the recent file list as it seems to be slowing down the opening process due to a series of perceptible delays. Is it possible to tweak this behaviour in Emacs? Absolutely! So far, I’ve incorporated the following consult-related packages:

consult-recent-file
consult-theme
consult-outline
consult-imenu

and I think the only preview that I require is consult-theme leading to the following configuration:

(consult-customize
 consult-theme :preview-key '(:debounce 0.2 any)
 consult-recent-file consult-outline consult-imenu consult-history :preview-key nil)

Emacs asynchronous copying using dired-async-mode

James Dyer — Sat, 20 Jan 2024 09:38:00 +0000

For a while now I’ve been using an rsync based dired-copy replacement for large copy asynchronous operations within emacs. It is not uncommon for me to want to copy large files in emacs and rather than waiting for the operation to finish I leveraged async-shell-command to perform an rsync copy as thus:

(define-key dired-mode-map (kbd "C") 'my/rsync)

(defun my/rsync (dest)
 "Rsync copy."
 (interactive
 (list
 (expand-file-name (read-file-name "rsync to:"
 (dired-dwim-target-directory)))))
 (let ((files (dired-get-marked-files nil current-prefix-arg))
 (command "rsync -arvz --progress --no-g "))
 (dolist (file files)
 (setq command (concat command (shell-quote-argument file) " ")))
 (setq command (concat command (shell-quote-argument dest)))
 (async-shell-command command "*rsync*")
 (dired-unmark-all-marks)
 (other-window 1)
 (sleep-for 1)
 (dired-revert)
 (revert-buffer nil t nil)))

Generally this has worked pretty well for me and as a plus I could see the progress in a buffer named *rsync* (although I would typically dismiss it quickly using winner-undo or maybe adding something to display-buffer-alist)

After watching the always excellent and informative video from Emacs Elements - Best Way to Sort and Play Videos Is with Emacs it opened my eyes to a built-in feature of emacs 29, namely dired-async-mode (Do dired actions asynchronously) which seems to pretty much do what it says.

To activate, rather than having to map all those dired commands to async versions, the following just needs to be set up :

(dired-async-mode 1)

Now when a copy via dired is activated it will happen asynchronously! - and also with other dired commands like rename but really it is generally a copy that will take the time.

Out of the box a normal copy in dired using C activates the asynchronous task and the modeline displays something like the following in all windows :

[1 Async job(s) running]

When finished the modeline updates with a copy complete message and then after three seconds disappears.

Three seconds you say? well how do I know that?, well I played around a little with the modeline finish message as of course this can be configured, this was my initial attempt:

(defun my/dired-async-mode-line-message (text face &rest args)
 "Notify end of async operation in `mode-line'."
 (let* ((my/message "Dired Async has finished!!")
 (mode-line-format (concat
 " " (propertize
 my/message
 'face
 '(:background "#ff0000" :foreground "#ffffff" :inherit bold)
 ))))
 (message my/message)
 (force-mode-line-update)
 (sit-for 8)
 (force-mode-line-update)))

(setq dired-async-message-function 'my/dired-async-mode-line-message)

I just felt I could try something a little more prominent to indicate the end of a copy but in the end I kept the default setup.

The only issue I have observed thus far is that on an initial emacs startup the modeline for all windows displays [0 Async job(s) running] and only seems to disappear after the first copy. It is a little annoying and even with the use of the diminish package my modeline can look a little cluttered. I might need to look at this.

Update <2024-01-20 Sat 12:05> Actually I do know why the above is happening, when I was messing around with the my/dired-async-mode-line-message function above I turned on (dired-async--modeline-mode 1) ooops! well now I have commented it out no modeline async message initially appears! - I thought I would just leave all this stuff in here 😀

My first emacs package - selected-window-accent-mode

James Dyer — Sat, 06 Jan 2024 21:00:00 +0000

From my previous two posts regarding defining a Selected Window Accent some interesting posts from irreal arose, especially:

Marking The Active Window

Where it looks like the simple mode-line-active and mode-line-inactive was a good way to indicate the current focussed window, and I do agree.

However to practice my elisp and to create my first emacs package I thought I would bring together my preference which is to have a tiling window manager type of focus involving typically a border around the current window while leveraging the usual customization options that come with emacs.

I have put it on github/captainflasmr for now and below is the README for a package called selected-window-accent-mode

It’s a bit rough around the edges (pardon the pun!) but I think it might be a good starting point for further improvements.

selected-window-accent-mode

Summary

The Selected Window Accent Mode is an Emacs package designed to visually distinguish the currently selected window by applying a unique accent color to its fringes, mode line, header line, and margins.

Quick Start (emacs 29)

Add the following to the emacs init for a tiling window manager feel (see image above):

(use-package selected-window-accent-mode
 :vc (:fetcher github :repo "captainflasmr/selected-window-accent-mode")
 :custom
 (selected-window-accent-fringe-thickness 10)
 (selected-window-accent-custom-color "#916941")
 (selected-window-accent-mode-style 'tiling))

(selected-window-accent-mode 1)

Installation

use-package (emacs 29)

Put the following into your emacs init file:

(use-package selected-window-accent-mode
 :vc (:fetcher github :repo "captainflasmr/selected-window-accent-mode"))

use-package (MELPA)

TODO (see roadmap below)

from source

Download the `.el` file and place it in your Emacs `load-path`.

Then either manually load it or add it to your configuration to be loaded at startup.

(require 'selected-window-accent-mode)

Usage

Interactively Toggle the mode on and off M-x selected-window-accent-mode

Interactively change the current style M-x switch-selected-window-accent-style which will present a completing-read selection in the minibuffer

The styles that are currently supported :

default
tiling
subtle

see roadmap below for a description.

Typically I have bound these two interactive functions to a new keymap where I keep all my emacs visual change functions.

(defvar my-win-keymap (make-sparse-keymap))
(global-set-key (kbd "M-o") my-win-keymap)
(define-key my-win-keymap (kbd "a") 'selected-window-accent-mode)
(define-key my-win-keymap (kbd "y") 'switch-selected-window-accent-style)

Examples

Example 1 - Default / custom color

To enable the accent mode automatically upon starting Emacs, add the following line to your `.emacs` or `init.el` file:

(use-package selected-window-accent-mode
 :vc (:fetcher github :repo "captainflasmr/selected-window-accent-mode")
 :custom
 (selected-window-accent-custom-color "goldenrod")
 (selected-window-accent-mode-style 'default))

(selected-window-accent-mode 1)

This will accent the modeline only for the selected window with the goldenrod color.

Example 2 - Tiling / custom color / custom fringe thickness

(setq selected-window-accent-fringe-thickness 6)
(setq selected-window-accent-custom-color "#4179b2")
(setq selected-window-accent-mode-style 'tiling)

(selected-window-accent-mode 1)

This will accent the full outline of the window with the color #4175b2 more akin to a tiling window manager.

Example 3 - Tiling / theme highlight color

(setq selected-window-accent-custom-color nil)
(setq selected-window-accent-mode-style 'tiling)

(selected-window-accent-mode 1)

This will accent the full outline of the window with the highlight color taken from the current theme.

Example 4 - Subtle / custom fringe thickness (thick)

(setq selected-window-accent-fringe-thickness 40)
(setq selected-window-accent-custom-color nil)
(setq selected-window-accent-mode-style 'subtle)

(selected-window-accent-mode 1)

This will accent the modeline and just the left fringe and in this case be quite a pronounced thick accent.

Customization

Can be done through the customization interface:

Selected Window Accent Group group:

Customization group for the selected-window-accent package.

Selected Window Accent Custom Color

Custom accent color for the selected window. Set this variable to change the accent color.

None - color will be using the current highlight face
Custom Color - input color name or Hex

Selected Window Accent Fringe Thickness: Integer:

The thickness of the fringes in pixels.

Selected Window Accent Mode: Boolean: Toggle

Non-nil if Selected-Window-Accent mode is enabled

Selected Window Accent Mode Style

Current style for accenting the selected window.

default - just modeline accent
tiling - window border accent
subtle - left and modeline accent

Minor Mode

The selected-window-accent-mode is a global minor mode that you can toggle to enable or disable the accenting of the selected window.

When enabled, it distinguishes the selected window with a special accent color.

Hooks

Two hooks are used to automatically update the window accents when the window configuration or state changes:

window-configuration-change-hook
window-state-change-hook

These are added when the selected-window-accent-mode is enabled and removed when disabled.

BUGS

The current version is pretty rough and probably definitely pre-alpha.

Fix these to get to a tagged Version 0.1.

In order of priority

TODO header-line not shown on window split.
TODO adjust the not selected-window margin to avoid little window navigation. disruption, hence translating a fringe pixel width to a number of margin characters, not quite sure how I am going to do this yet.
TODO Incorporate mode-line-active and mode-line-inactive somehow as this would make more sense especially in the ‘default mode.
TODO excess selected-window disruption in header-line.
WATCHING careful with removing header-line on all windows, for example magit commit window and probably some others may need to add some logic depending on mode.

ROADMAP

1. add to MELPA

2. define more custom variables:

accent color saturation adjustment
accent color darken adjustment
accent color hue adjustment

3. define which theme face attribute to use as the main accent color

Currently the default is to use the highlight face

4. DOING implement accent styles

DONE default - bottom - full height modeline
DOING tiling - top/right/bottom/left - typically a squished modeline and header line to a general accent thickness to provide a typical tiling window manager focussed outline experience
DOING subtle - left/bottom
TODO full - top/right/bottom/left - full height modeline (currently implemented as tiling but will be moved when tiling is more “tiling”)

Improvements to Selected Window Accent

James Dyer — Mon, 01 Jan 2024 21:12:00 +0000

Given my previous post regarding accenting the current window:

Selected Window Accent

“This routine provides a coloured left fringe accent on the selected window to emphasize the current working window.”

I had a little issue with visual-fill-column-mode in that :

Note that I also had to set the margins to make the window traversal less visually disturbing and it seems to affect visual-fill-column-mode in the fact that it doesn’t work, but maybe I can just try and not use it or eventually figure it out, but for now this is a starting point and I’m sure I will refine it over time.

With some trial and error the issue was that my new accent routine applied margins that overrode visual-fill-column-mode, causing display issues on window navigation.

So to fix I just re-activated visual-fill-column-mode if it was active.

(defun selected-window-accent ()
 (interactive)
 (set-face-background 'fringe "#77002e")
 (walk-windows
 (lambda (window)
 (if (eq window (selected-window))
 (progn
 (set-window-margins window 1 0)
 (with-selected-window window
 (if (eq visual-fill-column-mode t)
 (visual-fill-column-mode t)))
 (set-window-fringes window 10 0 t nil))
 (progn
 (set-window-margins window 2 0)
 (with-selected-window window
 (if (eq visual-fill-column-mode t)
 (visual-fill-column-mode t)))
 (set-window-fringes window 0 0 t nil))
 )
 )
 nil t))

(add-hook 'window-configuration-change-hook 'selected-window-accent)
(add-hook 'window-state-change-hook 'selected-window-accent)

Selected Window Accent

James Dyer — Fri, 22 Dec 2023 20:55:00 +0000

Borrowing from the concept of a tiling window manager I thought that emacs could better indicate the currently selected window by a form of highlight/emphasis like the following:

“This routine provides a coloured left fringe accent on the selected window to emphasize the current working window.”

Since I have been using more of an emacs tab-bar based work-flow I found myself spending a second or two looking for my current window when switching tabs. I would therefore like to more clearly visually identify the current working window (i.e, which window has my cursor in it) by the aid of some kind of accent or emphasis as is often the case in a tiling window manager. A blinking cursor could help with this, but I tend to prefer a non blinking block and I find hl-line-mode too distracting.

I thought I would just cobble together a proof of concept, nothing fancy, programatically inefficient, but hopefully an effective solution that works well enough while adhering to the KISS principle.

There are packages out there, for example pulsar and beacon for pulsing or emphasizing the cursor area when window navigating or auto-dim-other-buffers which face dims aspects of the entire window set for emphasis and actually I like its description:

The ‘auto-dim-other-buffers-mode’ is a global minor mode which makes windows without focus less prominent. With many windows in a frame, the idea is that this mode helps recognise which is the selected window by providing a non-intrusive but still noticeable visual indicator.

which is pretty much what I am looking to achieve but by using an accent rather than dimming.

So the solution?, overlays didn’t seem to fit and was more character point font based where I was initially looking to render some form of coloured graphical border overlay which is typically apparent in a standard tiling manager.

After a little investigation I decided on a simple (quick and dirty) solution and that is to utilise the left hand fringe.

I generally don’t ever have fringes in my emacs session and in fact set (set-fringe-mode '(0 . 0)).

The function set-fringe-margins allows a left and right pixel width value to be set for an individual window which is a good starting point. After a little investigation and trial and error I came up with the following which seemed to work well for me:

(defun my/selected-window-accent ()
 (interactive)
 (set-face-background 'fringe "#77002e")
 (walk-windows
 (lambda (window)
 (if (eq window (selected-window))
 (progn
 (set-window-margins window 1 0)
 (set-window-fringes window 16 0 t nil))
 (progn
 (set-window-margins window 3 0)
 (set-window-fringes window 0 0 t nil))
 )
 )
 nil t))

(add-hook 'window-state-change-hook 'my/selected-window-accent)

On a window change notification (for example, standard window navigation) all windows are traversed with the current window explicitly displaying the left fringe only to a defined colour. All the other non selected windows have their fringes removed or in this case the pixel sizes set to zero.

What we end up with here is a window accent on the left hand side of the selected window and when in combination with potentially a sensible mode-line configuration (maybe in the same accent colour) I think will serve as a decent visual window indicator. The width and colour can be simply modified to taste within the function itself, this is a very simple solution.

Note that I also had to set the margins to make the window traversal less visually disturbing and it seems to affect visual-fill-column-mode in the fact that it doesn’t work, but maybe I can just try and not use it or eventually figure it out, but for now this is a starting point and I’m sure I will refine it over time.

Redefining mark-paragraph and mark-word

James Dyer — Sat, 09 Dec 2023 11:50:00 +0000

I can’t say that I’m completely happy with the way emacs marks some elements, namely :

mark-paragraph

The default mark-paragraph visually selects a paragraph as follows:

but I think I would rather have the cursor show at the bottom of the selected paragraph, it just feels more natural to me, so as thus:

To achieve this I wrote the following with a rebind to the default mark-paragraph keybinding or in orgs case the mark-element


(defun my/mark-paragraph ()
 "redefinition of mark-paragraph"
 (interactive)
 (forward-char)
 (backward-paragraph)
 (push-mark)
 (forward-paragraph)
 (setq mark-active t))

(global-set-key (kbd "M-H") 'my/mark-paragraph)

I had to forward-char initially to step on to the paragraph if my cursor was just before the paragraph as this felt natural to me so that the backward-paragraph won’t jump to the previous paragraph.

So just a simple function with a few tweaks here and there to make the paragraph marking feel a little more natural, probably subconsciously taking cues from my time working with many different text editors and as always with emacs it is pretty awesome that this kind of low level finely grained functionality can be modified to such and extent.

mark-word

Next up is mark-word. I’m finding myself wanting to naturally just mark the current word my cursor is within and currently I feel I’m having to work quite hard to achieve this by a combination of backward/forward-word and marking.

The default mark-word (M-@) seems to only mark to the end of a word, as thus:

I would want something more like:

So I created the following function and rebound to the default mark-word :

(defun my/mark-word ()
 "redefinition of mark-word"
 (interactive)
 (backward-to-word 1)
 (forward-to-word 1)
 (push-mark)
 (forward-word)
 (setq mark-active t))

(global-set-key (kbd "M-@") 'my/mark-word)

This was trickier than I first thought as when I manually mark a word through a combination of key-presses I actually apply a little logic in that if the cursor is on the first character I don’t backward-word as this would take me to the previous word!

I might be able to work out if the cursor is on the first character of a word?, but the function starts to become unnecessarily complicated.

To solve this I used backward-to-word which moves backward until the end of a word. This will work irrespective of where my cursor is within the current word and then forwarding back on to the current word so my cursor is on the first character. At this point I can now mark and forward-word to select the word. Yes I have used word many times here, word, word, word, word, WORD!!!! 😀

Now typing all this out I wonder if there is a simple function to just move the cursor to the start of a word, if there is I couldn’t seem to find it, but as always I have learnt a lot along the way!

[Edited : <2023-12-10 Sun>]

Actually it is possible (of course!) to work out if the cursor is on the first character of a word (see comment section), so the amended function would look like:

(defun my/mark-word ()
 "redefinition of mark-word"
 (interactive)
 (if (not (looking-at "\\<"))
 (backward-word))
 (push-mark)
 (forward-word)
 (setq mark-active t))

I feel like this is a better solution.

Describe Character / Face Under Cursor

James Dyer — Sat, 02 Dec 2023 09:13:00 +0000

Every now and then I find myself tweaking the look of emacs and have started to build up a list of my own common faces in custom-set-faces to suit my needs, for example here is my current setup:

(custom-set-faces
 ;; custom-set-faces was added by Custom.
 ;; If you edit it by hand, you could mess it up, so be careful.
 ;; Your init file should contain only one such instance.
 ;; If there is more than one, they won't work right.
 '(cursor ((t (:background "#ffffff" :inverse-video t))))
 '(ediff-current-diff-A ((t (:extend t :background "#b5daeb" :foreground "#000000"))))
 '(ediff-even-diff-A ((t (:background "#bafbba" :foreground "#000000" :extend t))))
 '(ediff-fine-diff-A ((t (:background "#f4bd92" :foreground "#000000" :extend t))))
 '(ediff-odd-diff-A ((t (:background "#b8fbb8" :foreground "#000000" :extend t))))
 '(org-block ((t (:inherit fixed-pitch))))
 '(org-code ((t (:inherit (shadow fixed-pitch)))))
 '(org-date ((t (:inherit fixed-pitch))))
 '(org-document-info ((t (:foreground "#8f4800"))))
 '(org-document-info-keyword ((t (:inherit (shadow fixed-pitch)))))
 '(org-indent ((t (:inherit (org-hide fixed-pitch)))))
 '(org-link ((t (:foreground "#5555ff" :underline t))))
 '(org-meta-line ((t (:inherit (font-lock-comment-face fixed-pitch)))))
 '(org-tag ((t (:inherit (shadow fixed-pitch) :weight regular :height 0.7))))
 '(widget-button ((t (:inherit fixed-pitch :weight regular))))
 '(window-divider ((t (:foreground "black"))))
 '(vertical-border ((t (:foreground "#000000")))))

To help me work out the name of a certain face I use:

(describe-char)

typically accessed through C-x = (what-cursor-position) with the prefix argument, then accessing customize menu, saving changes, looking up the face changed in the init file and then copy and paste to my custom-set-faces above.

Quick Search Through Org Headers using Consult Outline

James Dyer — Sat, 18 Nov 2023 15:30:00 +0000

I’ve been on the lookout for an efficient way to swiftly scan through org headings exclusively for a specified input string, akin to the functionality of isearch. This would enable me to promptly navigate to a past blog post which is typically stored under an org heading.

By default, a standard isearch examines the entire file, a behaviour that in this case I don’t really want. I specifically need to limit the search to org headings only, allowing me to swiftly navigate to an org heading.

The best method I have found is to use consult-outline which I have bound to C-o

I had a play around with various org filtering options like org-goto and org-agenda but they didn’t really quite do what I wanted.

As it turns out leveraging the built-in outline-mode through consult-outline also comes with the additional benefit of being applicable to source code files.

Also in combination with embark-collect it means I can create a separate outline buffer which can simply be isearch’d through to refine my search further.

I seem to be using embark-collect more often these days so I bound a key to the mini-buffer map so I won’t necessarily need to go through the embark despatching mechanism each time I want to redirect the mini-buffer contents to a proper buffer:

(define-key minibuffer-local-map (kbd "C-c e") 'embark-collect)

I have also added consult-imenu to my arsenal of search weapons which I have bound to M-o. For example I have a very clearly defined commenting format in emacs init and sway configuration files so to jump through a file I can use imenu with consult instead.

Window Divider Mode

James Dyer — Sun, 05 Nov 2023 16:01:00 +0000

I was playing around with the look of emacs and thought it might be nice to have more control over the border between windows (I have now learnt that this is referred to as a window divider!)

Although I could change the colour using custom-set-faces (vertical-border ((t (:foreground "#444444")))) I wanted the default thin dividing window line to be larger, but initially I couldn’t seem to figure out how do change this.

I tried the vertical-border face :width :height at varying weights and in fact through the custom settings I toggled on and off pretty much everything, but to no avail.

This eventually led me to the built-in window-divider-mode which actually specifically handles the cosmetic divider issues, so I set the following:

(setq window-divider-default-bottom-width 8)
(setq window-divider-default-right-width 8)
(setq window-divider-default-places t)

(window-divider-mode 1)

I decided that if I was going to have a window divider then I might as well have it “around” every window, hence the default-places set to t rather than a very specific position, right-only or bottom-only

Digital Art Using Artist Mode #1

James Dyer — Fri, 27 Oct 2023 21:31:00 +0100

I have been using ArtRage, Krita and Infinite Painter for many years now but I thought I would try that other well known digital art tool… emacs!

Using the built-in artist-mode now I really can truly live in emacs full time!

Here is my emacs time-lapse! : https://youtu.be/1JZ6ljIRGus 😀

Better Syntax Highlighting Sway Configuration Files

James Dyer — Sun, 22 Oct 2023 21:20:00 +0100

I have been delving into the nuts and bolts of the Sway window manager lately and especially its fork SwayFX which adds a little eye candy in the style of Hyprland.

This has led to lots of sway config file editing and hence trying to work out the best way in emacs to work with them.

By default a typical sway/config file has its own configuration format and emacs tries its best to figure out which best mode to use and settles on conf-space-mode. This is a basic starter mode for a config that is space separated and gives me a rudimentary level of highlighting, for example :

I would like indentation to be a little more intelligent and currently this mode applies an ever increasing indent but I shall figure that out at a later date.

I was generally not unhappy with conf-space-mode as it gave me a rudimentary keyword form of highlighting and typically as a sway configuration file doesn’t need to be particularly structured I wasn’t ever really indenting anyway, but lets see if I can improve the syntax highlighting.

The first port of call is list-packages and searching for sway:

 sway - Communication with the Sway window manager
sway-lang-mode - Major mode for sway

Unfortunately both don’t suit my use case and in fact the second is for the sway programming language of which this is not!.

Well how about treesitter?, a big hard nope for this as well.

Next up is a little ace up my sleeve and one that continues to prove advantageous when working with the Sway tiling manager. It is the fact that SwayWM is a drop in replacement for i3wm. Well if the sway config files are of the same format as i3 config files then surely I can use some kind of i3 emacs mode? and so it proved to be the case!

 i3wm-config-mode - Better syntax highlighting for i3wm's config file

Explicitly running this mode gives me:

Much nicer! and comes with the following auto-mode-alist definition:

("i3/config\\'" . i3wm-config-mode)

which of course requires a little adjustment to auto associate this new i3 mode with my sway files. I came up with the following:

(add-to-list 'auto-mode-alist '("/sway/.*config.*/" . i3wm-config-mode))
(add-to-list 'auto-mode-alist '("/sway/config\\'" . i3wm-config-mode))

It took me a little while to figure out the regex as there are a few subtleties, for example it is recommended to always use \\’ rather than $ to eliminate the confusion around new lines.

Note that I put an extra directory slash at the regex start to stop the mode being applied to any other potential directories that might end in sway which I feel might be a more common future occurrence than a config directory containing i3.

More Improvements to Dired Duplicate Here

James Dyer — Fri, 13 Oct 2023 16:10:00 +0100

On a previous post I created an elisp function to quickly duplicate a file or directory in dired, by default it would copy the dired item under the cursor to an old suffix or append a number based on the universal argument.

Dired Duplicate Here Revisited

(defun my/dired-duplicate-file (arg)
 "Duplicate the current file in Dired."
 (interactive "p")
 (let ((filename (dired-get-filename)))
 (setq target (concat (file-name-sans-extension filename)
 "-old"
 (if (> arg 1) (number-to-string arg))
 (file-name-extension filename t)))
 (if (file-directory-p filename)
 (copy-directory filename target)
 (copy-file filename target))
 )
 )

This worked well for a while but now I want something a little more robust and after working within Krita for a while I decided that I would like to implement its incremental save naming convention.

It’s pretty simple really, just an incremented integer, zero padded to a width of 3, inserted just before the extension:

So I just need to apply a little counter logic but still have the potential to pass in the universal argument and of course avoid overriding any existing backup as it did before.

(defun my/dired-duplicate-file (arg)
 "Duplicate a file from dired with an incremented number.
 If ARG is provided, it sets the counter."
 (interactive "p")
 (let* ((file (dired-get-file-for-visit))
 (dir (file-name-directory file))
 (name (file-name-nondirectory file))
 (base-name (file-name-sans-extension name))
 (extension (file-name-extension name t))
 (counter (if arg (prefix-numeric-value arg) 1))
 (new-file))
 (while (and (setq new-file
 (format "%s%s_%03d%s" dir base-name counter extension))
 (file-exists-p new-file))
 (setq counter (1+ counter)))
 (if (file-directory-p file)
 (copy-directory file new-file)
 (copy-file file new-file))
 (dired-revert)))

I can now create any number of dired file/directory backups quickly from dired (well up to 100).

More Improvements To My Weight Loss Org Table

James Dyer — Fri, 06 Oct 2023 18:59:00 +0100

More improvements to my weight loss table, this time I have added the following:

The first column now auto populates an incremental integer

Extra column to display the average loss

 #+PLOT: title:"Weight Loss" ind:1 deps:(4) type:2d with:lines set:"yrange [150:220]"
 | | date | stn | pnd | lss | tot | bar | av-loss |
 |---+------------------+-------+-----+-----+-----+----------------+---------|
 | 0 | <2023-08-18 Fri> | 15:5 | 215 | | | WWWWWWWWWWWWWH | |
 | 1 | <2023-08-25 Fri> | 14:9 | 205 | -10 | -10 | WWWWWWWWWWWV | 10.0 |
 | 2 | <2023-09-01 Fri> | 14:2 | 198 | -7 | -17 | WWWWWWWWWW; | 8.5 |
 | 3 | <2023-09-08 Fri> | 13:11 | 193 | -5 | -22 | WWWWWWWWW: | 7.3 |
 | 4 | <2023-09-15 Fri> | 13:10 | 192 | -1 | -23 | WWWWWWWWW | 5.8 |
 | 5 | <2023-09-22 Fri> | 13:9 | 191 | -1 | -24 | WWWWWWWWV | 4.8 |
 | | | | | | | | |
 #+TBLFM: $1=@#-2::$4='(convert-weight $3)::@3$5..@>$5=$4-@-1$4::@3$6..@>$6=vsum(@$5..@3$5)::$7='(orgtbl-ascii-draw $4 150 220 15)::@3$8..@>$8=abs(vmean(@3$5..@$5));%0.1f

On my last org weight table post a comment pointed out that there was a better way to populate the first integer column, so rather than a key-press S-RET (org-table-copy-down) rows can be auto populated using the $1=@#-2 equation in the #+TBLFM line.
I thought it might be interesting to plot he average weight loss to gain a more general perspective and to see the average weekly value settle down over a period of time. For this I added

@3$8..@>$8=abs(vmean(@3$5..@$5));%0.1f

which leverages the calc functions of vmean to average out the previous loss values and then apply an absolute value using the function abs.

I also found that I needed to find a way to display the table value to 1.d.p which was achieved by %0.1f

Recursively Listing Files in Size Order using find-name-dired

James Dyer — Sun, 01 Oct 2023 21:31:00 +0100

For a while now I have been looking for a simple method in emacs for trimming down my largest files, usually this means locating those large image files and compressing them as I like keeping my media compressed or deleting any large files I didn’t know were lurking around my system.

The obvious choice for this is find-name-dired but for me always had the annoying habit of reordering the final result after finishing the recursive search. Even if I set the find-ls-option correctly (not necessarily an easy task) to sort by size the final dired buffer output would always keep resetting to sort by file name.

It took me a while delving into the nuts and bolts of find-name-dired but I finally realised that after processing using the find-ls-option a function find-dired-refine-function is called which by default is set to find-dired-sort-by-filename which:

Sorts entries in Find buffer by file name lexicographically.

Why this does this I have no idea (perhaps it is because the output of the find command ends up in a dired buffer which would always generally make sense to sort by name?), but as I will only ever want to use find-name-dired to list files in size order and then to prune any or compress them using standard dired commands then I can just do the following:

(setq find-dired-refine-function 'nil)
(setq find-ls-option (cons "-exec ls -lSh {} +" "-lSh"))

Which will honour the intended find-ls-option to do exactly what it says on the tin and that is to:

-l : long list as =dired= will always need this form of listing
-S : Sort by file size
-h : Show size in human readable form, which doesn't seem to affect the sorting

For me this seems to be a more transparent method and of course I guess other standard ls options can now be passed through to dired, for example for files in order of time, you would pass -t

Plotting Other Org Tables

James Dyer — Tue, 26 Sep 2023 21:30:00 +0100

I’m currently in the process of learning how to create graphical plots from org tables using gnuplot. I’ve noticed that it’s generally more straightforward to extract x-axis data from an org table column with incrementing numbers, as opposed to relying on gnuplot to potentially sort out data from an existing column (which may not be plot-friendly)

Generally my existing org tables do not have such an incrementing integer column, so how do I quickly create and populate such a column?, well actually it is super easy, barely an inconvenience!

For example take the following table that represents a little flutter on the horses, how would I go about plotting the Total column and therefore clearly visualise the downward sloping line 😀

| Date | Horse | Stk | Ret | Prof | Total |
|--------+----------------+-----+-------+-------+--------|
| | | | | 0 | 306.9 |
| 27 May | aggagio | 15 | 7.68 | -7.32 | 299.58 |
| | red derek | 15 | 0 | -15 | 284.58 |
| 03 Jun | dear my friend | 10 | 0 | -10 | 274.58 |
| | the foxes | 10 | 32 | 22 | 296.58 |
| | sprewell | 10 | 16 | 6 | 302.58 |
| | dancing poet | 15 | 16.73 | 1.73 | 304.31 |

Firstly simply M-S-<right> to insert a table column:

| | Date | Horse | Stk | Ret | Prof | Total |
|---+--------+----------------+-----+-------+-------+--------|
| | | | | | 0 | 306.9 |
| | 27 May | aggagio | 15 | 7.68 | -7.32 | 299.58 |
| | | red derek | 15 | 0 | -15 | 284.58 |
| | 03 Jun | dear my friend | 10 | 0 | -10 | 274.58 |
| | | the foxes | 10 | 32 | 22 | 296.58 |
| | | sprewell | 10 | 16 | 6 | 302.58 |
| | | dancing poet | 15 | 16.73 | 1.73 | 304.31 |

Now move the cursor to the starting point and put in an initial integer:

| | Date | Horse | Stk | Ret | Prof | Total |
|---+--------+----------------+-----+-------+-------+--------|
| 1 | | | | | 0 | 306.9 |
| | 27 May | aggagio | 15 | 7.68 | -7.32 | 299.58 |
| | | red derek | 15 | 0 | -15 | 284.58 |
| | 03 Jun | dear my friend | 10 | 0 | -10 | 274.58 |
| | | the foxes | 10 | 32 | 22 | 296.58 |
| | | sprewell | 10 | 16 | 6 | 302.58 |
| | | dancing poet | 15 | 16.73 | 1.73 | 304.31 |

Now just simply S-Enter (org-table-copy-down) which will fill an incremented number downwards as far as you want:

| | Date | Horse | Stk | Ret | Prof | Total |
|---+--------+----------------+-----+-------+-------+--------|
| 1 | | | | | 0 | 306.9 |
| 2 | 27 May | aggagio | 15 | 7.68 | -7.32 | 299.58 |
| 3 | | red derek | 15 | 0 | -15 | 284.58 |
| 4 | 03 Jun | dear my friend | 10 | 0 | -10 | 274.58 |
| 5 | | the foxes | 10 | 32 | 22 | 296.58 |
| 6 | | sprewell | 10 | 16 | 6 | 302.58 |
| 7 | | dancing poet | 15 | 16.73 | 1.73 | 304.31 |

Now I can use a #+PLOT header to reference the first column for the x axis:

#+PLOT: title:"Betting" ind:1 deps:(7) type:2d with:lines set:"yrange [250:350]"
| | Date | Horse | Stk | Ret | Prof | Total |
|---+--------+----------------+-----+-------+-------+--------|
| 1 | | | | | 0 | 306.9 |
| 2 | 27 May | aggagio | 15 | 7.68 | -7.32 | 299.58 |
| 3 | | red derek | 15 | 0 | -15 | 284.58 |
| 4 | 03 Jun | dear my friend | 10 | 0 | -10 | 274.58 |
| 5 | | the foxes | 10 | 32 | 22 | 296.58 |
| 6 | | sprewell | 10 | 16 | 6 | 302.58 |
| 7 | | dancing poet | 15 | 16.73 | 1.73 | 304.31 |

which will produce the following plot:

Not such a downward spiral as I first thought!

Plotting Org Table Weight Loss Using gnuplot

James Dyer — Fri, 22 Sep 2023 13:40:00 +0100

Now I have a weight loss org table defined and therefore an easy way to track the total amount of weight loss each week I had an idea for an improvement with some form of a satisfying graphical representation.

I have been aware of gnuplot for while now and I think this is an opportunity to give it a try through org-mode

The first step is a simple (use-package gnuplot)

here is the original table:

| date | weight | pounds | loss | total |
|------------------+--------+--------+------+-------|
| <2023-08-18 Fri> | 15:5 | 215 | | |
| <2023-08-25 Fri> | 14:9 | 205 | -10 | -10 |
| <2023-09-01 Fri> | 14:2 | 198 | -7 | -17 |
| <2023-09-08 Fri> | 13:11 | 193 | -5 | -22 |
#+TBLFM: $3='(convert-weight $2)::@3$4..@>$4=$3-@-1$3::@3$5..@>$5=vsum(@$4..@3$4)

and with a little investigation and trial and error I came up with:

#+PLOT: title:"Weight Loss" ind:1 deps:(4) type:2d with:lines set:"yrange [150:220]"
| | date | stn | pnd | lss | tot | bar |
|---+------------------+-------+-----+-----+-----+----------------|
| 0 | <2023-08-18 Fri> | 15:5 | 215 | | | WWWWWWWWWWWWWH |
| 1 | <2023-08-25 Fri> | 14:9 | 205 | -10 | -10 | WWWWWWWWWWWV |
| 2 | <2023-09-01 Fri> | 14:2 | 198 | -7 | -17 | WWWWWWWWWW; |
| 3 | <2023-09-08 Fri> | 13:11 | 193 | -5 | -22 | WWWWWWWWW: |
| 4 | <2023-09-15 Fri> | 13:10 | 192 | -1 | -23 | WWWWWWWWW |
| 5 | <2023-09-22 Fri> | 13:9 | 191 | -1 | -24 | WWWWWWWWV |
#+TBLFM: $4='(convert-weight $3)::@3$5..@>$5=$4-@-1$4::@3$6..@>$6=vsum(@$5..@3$5)::$7='(orgtbl-ascii-draw $4 150 220 15)

The first thing to point out is that as I was learning more about org tables I came across the orgtbl-ascii-draw function which visually is quite self explanatory as shown in the bar column. The main arguments are the x axis range (150-220) and the span in characters (15)

Now on to the main plotting change and that is defining a #+PLOT header setting out all the parameters I want fed into gnuplot from the org table.

Again most of the defines are self explanatory and the only issue I ran into was trying to get plot lines to be rendered based off the original first date column. The histograms display did work and correctly listed each week with the corresponding bar value but lines only displayed a single vertical line at a 2023 value.

I am guessing in the case of a line display the data is plotted in a more non discrete manner and the date was parsed as best it could and just plucked out the first part of the date string which was the year. I decided not to investigate this and instead simply added another column with a simple numbering scheme and set my x axis off of that. I only want to see a plot over a number of weeks so I don’t care about the display of the date.

So now lets generate the gnuplot! which can be accomplished by running C-c " g (org-plot/gnuplot):

Opening Files Externally from dired

James Dyer — Sat, 16 Sep 2023 16:43:00 +0100

I have been using C-RET or W in dired for a while now to open a file externally via browse-url-of-dired-file.

I was never quite sure how that worked but it just worked, however now it doesn’t work so I need to do something about it.

I suspect that the reason it doesn’t work now is that I have been hopping around different window managers / compositors. My tried and tested workhorse environment is generally kde plasma on arch where the browse-url-of-dired-file was working just fine, but now I have switched to sway / wayland or i3 / x11 this functionality seems to be broken.

I have an idea it’s probably related to the window manager and the way each one handles default applications through the XDG portal. I think I need to find a more agnostic opening method.

My first thought was the openwith package but this had the side effect of opening every single file externally (especially when coming back from a desktop-save) which is not something I find desirable. I prefer the default dired mechanism for opening a file in emacs itself and I want an explicit mechanism to push a file to a native external application.

My next thought was dired-do-shell-command which can be activated by ! or X in dired. This brings up a default opening application called xloadimage which I’m assuming runs through possibly an XDG default application opening mechanism linked to the running window manager. Well I don’t really want to set a default application for each window manager / environment so I’m not sure that this is right approach either.

My next thought was how does dired determine which opening mechanism to use, I mean where does xloadimage come from?

Well the answer is twofold, firstly dired-guess-shell-alist-default and secondly dired-guess-shell-alist-user

The first list includes many lines in an alist format, for example:

("\\.jpe?g\\'" "xloadimage")

I don’t really want to touch the default settings so lets have a look at the user variant which is described as follows:

User-defined alist of rules for suggested commands. These rules take precedence over the predefined rules in the variable ‘dired-guess-shell-alist-default’ (to which they are prepended).

I therefore appended the prepended list! (even though it was empty anyway)

(setq dired-guess-shell-alist-user
 (append '(("\\.\\(jpg\\|jpeg\\|png\\|gif\\|bmp\\)$" "gwenview")
 ("\\.\\(mp4\\|mkv\\|avi\\|mov\\|wmv\\|flv\\|mpg\\)$" "mpv"))
 dired-guess-shell-alist-user))

Now to the testing stage…

I seem to have an intermittent problem when running ! (dired-do-shell-command) in that the file isn’t always opened in gwenview, however mpv opens every single time!. I literally have no idea what is going on here but & (dired-do-async-shell-command) opens every time! so lets use that then, it might be better to run the file opening asynchronously anyway.

However, another issue presents itself. By default the async shell window always opens a new buffer / window and is polluting my emacs window layout!!!!. Well certainly I can’t have that so I decide to use the display-buffer-alist as follows:

(defvar go-away-repl-regexp
 (rx bos "*" (or "Async")
 (zero-or-more nonl))
 "Regexp for matching windows to disappear")

(add-to-list 'display-buffer-alist
 `(,go-away-repl-regexp
 display-buffer-no-window
 (inhibit-same-window . t)))

Done.

Org Table to Calculate Weight Loss

James Dyer — Tue, 12 Sep 2023 21:11:00 +0100

For a while now I have been using org tables to represent and calculate pieces of data, obviating the need to open up a normal spreadsheet.

Recently I have been wanting to create a table to keep track of weight loss and this is what I came up with (with example weights):

| date | weight | pounds | loss | total |
|------------------+--------+--------+------+-------|
| <2023-08-18 Fri> | 15:5 | 215 | | |
| <2023-08-25 Fri> | 14:9 | 205 | -10 | -10 |
| <2023-09-01 Fri> | 14:2 | 198 | -7 | -17 |
| <2023-09-08 Fri> | 13:11 | 193 | -5 | -22 |
#+TBLFM: $3='(convert-weight $2)::@3$4..@>$4=$3-@-1$3::@3$5..@>$5=vsum(@$4..@3$4)

The initial difficulty was my British attachment to the imperial system which means always defining a human weight in stone and pounds. I had to initially define the following function to parse the weight string value into a numeric total pounds representation.

(defun convert-weight (weight)
 (let* ((parts (split-string weight ":"))
 (stone (string-to-number (car parts)))
 (pounds (string-to-number (cadr parts))))
 (+ (* stone 14) pounds)))

After the date and weight is inserted the total pounds can be calculated as thus :

$3='(convert-weight $2)

which is calculated for every data row.

I can now more easily calculate the loss each week with a simple org table equation and hence a total cumulative loss.

I think I can use calc in some way in an org table but for me this method seems easier and I have complete control over my weight input string.

The next issue is one I have run across many times with org tables and that is catering for a first line calculation. This is where I have to start getting my head around cell referencing.

For this I found the C-} (org-table-toggle-coordinate-overlays) very useful which explicitly shows the cell reference positions. The row column identifier often catches me out as the row specification only counts data lines and not things like headline fillers.

Org seems to prefer the @ROWS$COLUMN convention and although this doesn’t feel intuitive to me (I prefer it the other way) I thought I would stick with it and just adjust my thinking.

The loss calculation although a simple one needs to only take place on those data rows that have a previous weekly weight value, namely all those data rows not in the first data line.

Therefore I specifiy a range:

@3$4..@>$4=$3-@-1$3

Note the @> which references the last row.

Note: I think I could make this more flexible by specifying an offset from the hline, namely @I+1

Finally I need to add in a running cumulative total and again I had to consider not calculating on the first data line:

@3$5..@>$5=vsum(@$4..@3$4)

So that’s just about it for ongoing measurements. I just need to insert a new row at the bottom of the table, insert a date and current weight and on recalculation all the work is done for me!

My Evolving Modeline

James Dyer — Sat, 02 Sep 2023 12:32:00 +0100

I am a tinkerer and of course emacs is a perfect vehicle for this mentality. A prime example of this is my constant evolving modeline. For many years the default modeline hasn’t presented itself as being a problem, but is it optimal for me?, the answer I have now realised is no, and I think I can do better for my use cases.

So after a period of introspection (regarding emacs! 🙂) I think I can now define a clear set of criteria for my perfect modeline:

Show the full pathname

By default, emacs displays the buffer name, but during coding sessions, I often prefer to see the full file path, especially since I sometimes work with multiple copies of files with the same name.
Clearly indicate when a file has been modified

For when I accidentally insert a ’n’ or ‘p’ character in a buffer (I think you can guess how this happens!) it will be immediately apparent and I will be less likely to break my emacs config.
Have control over the faces

Define my own sizing and colouring for an active and inactive buffer modeline to make clearer my current selected buffer. Otherwise I will be at the whim of my current theme which may not always be optimal.
Efficient information display

Fit as much information in a compact manner as possible, I don’t want to be hunting around for buffer information, for example the column number and major modes should always be displayed.
Version control menu should be available

I frequently use git/magit for version control and prefer to keep the menu bar disabled. This choice sometimes leads me to search for built-in VC (Version Control) commands within emacs. For instance, registering a new file in magit can be tricky since untracked files seem to only display top-level directories unless a subdirectory file has been registered. To include all files in a directory, I rely on vc-register, but I don’t always remember the key chord. Therefore, having a VC menu in the mode line is immensely helpful.
Simplicity

This includes keeping the modeline elisp definition as simple as possible for easier maintainability / transparency and never allowing extra items to creep in like email or miscellaneous information.

Given all this I have come up with the following:

(setq-default mode-line-modified
 '(:eval (if (and (buffer-file-name) (buffer-modified-p))
 (propertize " * Modified " 'face
 '(:background "#e20023" :foreground "#ffffff")) "")))
(set-face-attribute 'mode-line-active nil :height 125
 :background "#ffffff" :foreground "#000000")
(set-face-attribute 'mode-line-inactive nil :height 110
 :background "#000000" :foreground "#ffffff")
(set-face-attribute 'mode-line nil :height 120)
(set-face-attribute 'mode-line-inactive nil :height 120)

(setq-default mode-line-format
 '("%e"
 mode-line-modified
 (:eval
 (if (buffer-file-name)
 (if (mode-line-window-selected-p)
 (propertize (format "%s " (abbreviate-file-name (buffer-file-name)))
 'face '(:background "#6b91c0" :foreground "#ffffff" :inherit bold))
 (format "%s " (abbreviate-file-name (buffer-file-name)))
 )
 )
 )
 (:eval
 (if (mode-line-window-selected-p)
 (propertize "%o %4l %2c %b"
 'face '(:background "#b8b8b8" :foreground "#000000"))
 "%o %4l %2c %b"))
 (vc-mode vc-mode)
 mode-line-modes
 )
 )
(setq mode-line-compact t)

I have tried to use the built-in modeline variables where possible and use mode-line-compact which replaces repeating spaces with a single space.

I found the best way to indicate a modified file and for it to clearly stand out on the modeline is by colour and string length, but I still wanted to keep the asterisk convention as this is quite common.

I decided to subtly change the size of the active and inactive modeline for extra emphasis and this can be massively exaggerated to taste.

ahk-mode and Updating To AutoHotKey Version 2

James Dyer — Fri, 25 Aug 2023 14:10:00 +0100

I have now managed to set up my external USB numeric keypad on Linux using kmonad which lets me use any regular plugged-in number keypad as a shortcut tool for my digital art.

This comes in very handy when painting in Krita and ArtRage (through Wine) and maybe one day I will expand this functionality to GIMP when version 3.0 comes out!

I would like the same keymapping functionality to be reflected on Windows (as ArtRage is fundamentally a Windows application). Technically kmonad should work but I’m going to use AutoHotKey as I’m much more familiar with it.

I have a problem though, my old autohotkey scripts don’t work with the latest version of AutoHotKey (version 2). On further investigation it seems that version 2 is a significant update and includes the simplification and shift of the syntax.

Well I guess I had better update my scripts then!.

On Windows by default an ahk extension offers to open notepad which initially I did as I thought the changes would be simple enough and actually notepad isn’t too bad these days what with the multiple tabs, dark mode and even multiple undos!. However I quickly became frustrated with the lack of syntax highlighting / indenting e.t.c. I have used a specific ahk editor in the past, something like SciTE4AutoHotkey but this time I thought I would break out emacs and see what it had to offer.

Initially loading the ahk script started fundamental mode and of course had no syntax highlighting. Running list-packages and then a quick search for AutoHotkey brought up the only package available, which was ahk-mode. This package seems pretty straightforward and although it was last updated in 2016 (so won’t cater too well with the AutoHotkey v2 shift in syntax) the syntax highlighting, commenting and indenting were just fine enough for me. It also seems to be well integrated with company-mode and although I’m not a great fan of company-mode in general in this case it might actually be useful.

I was now able to comfortably convert my scripts to AutoHotKey v2, for example:

version 1

#IfWinActive, ahk_class ArtRage 3
NumpadDiv:: ^z
NumpadMult:: ^y
NumpadHome::Shift
NumpadUp:: Alt
NumpadLeft:: Space
NumpadRight::
GetKeyState, state, h
if state = D
Send {h up}
else
Send {h down}
return
NumpadEnd:: Control
NumpadPgDn:: RButton

version 2

#HotIf WinActive("ahk_class ArtRage 3")
NumpadDiv:: ^z
NumpadMult:: ^y
NumpadHome::Shift
NumpadUp:: Alt
NumpadLeft:: Space
NumpadRight::
{
if GetKeyState("h")
Send "{h up}"
else
Send "{h down}"
}
NumpadEnd:: Control
NumpadPgDn:: RButton

While I was in amongst the scripts I decided to add in something extra and that is to map the Capslock key to the Control key; a not uncommon mapping for a regular emacs user.

So I added in the following line and plonked the script into the Windows startup folder:

Capslock::Control

Reverting Buffers

James Dyer — Mon, 21 Aug 2023 12:59:00 +0100

It is not uncommon for me to want to revert my current buffer.

For a long while I have used (find-alternate-file) which by default is bound to C-x C-v

Recently I switched to mapping this keybinding to revert-buffer but now I have found out about:

(revert-buffer-quick &optional AUTO-SAVE)
Like ‘revert-buffer’, but asks for less confirmation.
If the current buffer is visiting a file, and the buffer is not
modified, no confirmation is required.

It is bound to C-x x g and has the added benefit of not always asking for confirmation!

I will try and add this new command to my muscle memory but shall I just unbind my old revert-buffer key-mapping or rebind C-x C-v to this new function also?, in other words should I fully commit?

Fun With Emacs Theming Using Alpha Background on Wayland

James Dyer — Sat, 19 Aug 2023 10:55:00 +0100

Simply put here is me playing around with emacs transparency using alpha-background to set up sway the way I want it to look - I think there is some kind of well known term for this! (no neofetch involved 🙂)

No Bell For Me

James Dyer — Thu, 17 Aug 2023 17:01:00 +0100

Now I have set (pixel-scroll-precision-mode 1) which comes with emacs 29 this has led to an unexpected issue in that I now often get the following messages which cause a bell sound to be generated each time:

pixel-scroll-precision-scroll-up-page: Beginning of buffer [22 times]
pixel-scroll-precision-scroll-down-page: End of buffer [54 times]

I had turned to (setq visible-bell t) in the past but this generates an annoying flash each time rather than an annoying bell sound.

There is a solution to this of course and that is (setq ring-bell-function 'ignore) in that we are silent when a visual bell is rung, ah pure bliss 🙂🔔

Emacs 29.1 Transparency Alpha On Sway

James Dyer — Sat, 12 Aug 2023 15:36:00 +0100

I have just been been going through the new features added to emacs 29.1 and have been trying out the transparency or alpha-background on sway.

“alpha-background controls the opacity of the text background when running on a composited display.”.

I was keenly looking for an emacs improvement to the swaywm built in compositing method which in the case of emacs would make transparent the whole window including text which of course isn’t ideal.

I had defined the following in my sway config file:

for_window [class="Emacs"] opacity 0.92

0.92 seemed to be the perfect balance between wallpaper visibility and text legibility.

I am now going to compare the emacs alpha-background method with an equivalent sway emacs compositing opacity.

So for emacs I am going to set something like:

(set-frame-parameter nil 'alpha-background 70)
(add-to-list 'default-frame-alist '(alpha-background . 70))

See the following images for a comparison (can you guess which is which?) - I would suggest opening each image in separate browser tabs and comparing that way.

Note/Disclaimer: I chose opacity values that displayed an equivalent wallpaper visibility through emacs and as it turned out the opacity values were different which I suspect relates to the way the sway compositor is processing its opacity value rather than the way emacs does it but the demonstration fundamentally should still be a valid one.

and here is a more detailed comparison on a selected screen region:

Suffice it to say that this is a very nice improvement and certainly something I shall be using from now on.

Saving My Favourite Wallpapers

James Dyer — Fri, 11 Aug 2023 05:22:00 +0100

I am using the styli.sh script as my wallpaper changer in sway and with a little transparency and wallpapers from unsplash I can quickly switch randomly through my wallpaper images and get things looking pretty nice.

I tend to switch a few times before I find one that I like, but that image tends to disappear when I restart my laptop and the wallpaper gets reset. What I would like to do is to have the ability to send the current wallpaper to a wallpaper favourite folder to build up a chosen set of images.

The first step to achieving this would be to add a couple of lines to the styli.sh bash script to copy the current wallpaper image to a defined location. I am guessing that sway stores this image somewhere but as styli.sh handles all the variables and logic I might as well add in the following:

swaymsg output "*" bg "$WALLPAPER" "$MODE"
rm ~/wallpaper-faves*.{jpg,jpeg,png,gif}
cp "$WALLPAPER" ~/wallpaper-faves-${WALLPAPER##*/}

and now for some emacs elisp to move this wallpaper image into a favourite folder :

(defun my/copy-background-to-faves ()
 "Copy the current sway background to wallpaper faves folder"
 (interactive)
 (let* ((source-folder "/path/to/home/")
 (faves-folder "/path/to/wallpaper/faves/")
 (image-files (directory-files source-folder nil "^wallpaper-faves.*\\.\\(jpg\\|jpeg\\|png\\|gif\\)$" nil nil)))
 (dolist (image-file image-files)
 (rename-file (concat source-folder image-file) (concat faves-folder image-file) t)
 )
 )
 )

Now over time my faves-folder will build up with all my cherished wallpapers and I can begin the process again!

Simplifying My Modeline

James Dyer — Sun, 06 Aug 2023 09:22:00 +0100

After watching the latest informative video from Protesilaos Stavrou (Prot):

Emacs: write custom mode line

I decided to try and create my own simple mode line incorporating the features I regularly glance at throughout a day. Having mu4e and magit details on my mode line plus other mysterious characters seems a bit much.

After adapting the examples given in the video I created the following:

(setq-default mode-line-format
 '("%e"
 " %o "
 "%* "
 my-modeline-buffer-name
 my-modeline-major-mode))

(defvar-local my-modeline-buffer-name
 '(:eval
 (when (mode-line-window-selected-p)
 (propertize (format " %s " (buffer-name))
 'face '(t :background "#3355bb" :foreground "white" :inherit bold))))
 "Mode line construct to display the buffer name.")

(put 'my-modeline-buffer-name 'risky-local-variable t)

(defvar-local my-modeline-major-mode
 '(:eval
 (list
 (propertize "λ" 'face 'shadow)
 " "
 (propertize (capitalize (symbol-name major-mode)) 'face 'bold)))
 "Mode line construct to display the major mode.")

(put 'my-modeline-major-mode 'risky-local-variable t)

I left in %e as suggested to show an error message if memory was full.

%o for how far through the buffer I am. I have my scroll bars disabled but always find it useful to see where I am in a file especially when coding or within a large org file (for example when applying some repetitive macros seeing 80% through the buffer is quite motivating!)

%* to indicate if a file has been modified using the asterisk convention which is common in many other programs and has the side-effect of removing all other cryptic characters that I don’t understand. In the future I can always add some back in again but at that point I will (hopefully) understand what I am reintroducing.

Finally it is just the case of adding the buffer name and major mode which comes straight from the examples given in the video.

I especially like the control over the file name colour profile in combination with the use of the mode-line-window-selected-p function (introduced as part of emacs 29) which helps to identify the buffer in focus.

As with all these things I will use it and adapt accordingly and hopefully not feel the need to add everything back in again!, I think I like this simplicity for now.

Showing Org Agenda For The Year

James Dyer — Fri, 04 Aug 2023 06:21:00 +0100

I am just starting to include more of my org files into org-agenda. By default C-c a a gives a show for the next 7 days but I think for now I would like something of a more calendarish overview with a long form look of scheduled and completed tasks.

I thought I would write an elisp function:

(defun display-year-agenda (&optional year)
 "Display an agenda entry for a whole year."
 (interactive (list (read-string "Enter the year: "
 (format-time-string "%Y" (current-time)))))
 (setq year (string-to-number year))
 (org-agenda-list)
 (org-agenda-year-view year)
 (setq this-year (string-to-number (format-time-string "%Y" (current-time))))
 (when (= year this-year)
 (org-agenda-goto-today)
 (recenter-top-bottom 10)))

;; Bind a key for easy access
(global-set-key (kbd "C-c y") 'display-year-agenda)

The default prompt is the current year but with the ability to enter any year desired. I also thought that if calling up this current year then I would want to highlight today and recenter a little.

As with all things I will give this a go for a while and see if it fits nicely into my workflow.

Shrinking Media With The Help Of Emacs

James Dyer — Sun, 30 Jul 2023 15:28:00 +0100

Often I find myself refining my collection of photos and family videos, usually with the following process:

removing media clutter
removing any duplicates
tagging as necessary
compressing where reasonable
renaming to a more denote format

Emacs and the associated muscle memory greatly helps with this process.

Firstly though I leverage other applications, for example, duplicate removal and tagging takes place through digikam, media clutter through thunar and gthumb

My emacs process is then:

open media directory in dired
sort by size using C-u s S - the big S is setting the ls format by size
M-< (beginning-of-buffer) - so I can see the largest files
if I want to squish a video I will probably want to preview it first in mpv, so I do this asynchronously using & (dired-do-async-shell-command) and relying on my defined dired-guess-shell-alist-user setup and then selecting i (mpv shortcut) to have a quick peek at the original dimensions. Typically if the video is 1920x1080 then I like to halve the dimensions which when running through ffmpeg saves about 80-90% on disk space.

I have my own ffmpeg bash scripts which I call through dwim-shell-command so a command search for something like dw sh my/dwim-video-shrink will dired execute the file under cursor or over a list of marked files.
for images I again use dwim-shell-command with a quick command search for something like dw cr my/dwim-picture-crush which isn’t always as brutal as it might suggest but a script that I regularly modify when compressing images, setting the compression parameters appropriately.

If I need to quickly inspect the image then I could open it in emacs but I prefer again to open in gthumb using &
Possibly at the end of a directory compress I might check the directory size by ? in dired which I have mapped to an elisp my/get-file-size function that runs the async-shell-command du -
and of course my files can be easily renamed through wdired

As I am using a tiling window manager all of this can be accomplished keyboard only and on a single screen!

Defining Categories in Org Files for Hugo

James Dyer — Fri, 21 Jul 2023 13:02:00 +0100

I use Hugo to generate my web site and I made a decision early on to use ox-hugo withing emacs and to manage a single large org file with each subheading a blog post and each subheading tag representing… well, tags! I was aware of the concept of defining categories but decided to sort that out at a later date until I really understood what I was doing - this is a common thing that I do.

Well now I think I understand what I’m doing and now I want to create categories for my web site and as it turns out managing my posts within org files means that this can be achieved very easily.

For example, I have the following set up in my org file:

* Emacs [0/0] :emacs:linux:
** DONE Initial focus in Occur Buffer :occur:elisp:2023:
** DONE Cursor Blinking Rate :2023:

This means that the subheadings / posts under the top level Emacs heading inherit the emacs and linux tags and then define any extra specific to each post as desired. As these tags are defined at the top level then you could almost say they are defining a more broad definition, lets say a category!

So how do I change these top level tags to categories?, well I define the following:

* Emacs [0/0] :@emacs:@linux:

It is just a very slight change to the org tag definition after which I just need to re-export all my blog posts / subheadings using the ox-hugo dispatcher.

The generated markdown files now contain the following front matter which Hugo can now process accordingly:

tags = ["occur", "elisp", "2023"]
categories = ["emacs", "linux"]

Simple! and in fact you can see an example of how the categories are incorporated in this very web site!

Porting Dolphin Context Sensitive Scripts To Thunar

James Dyer — Mon, 10 Jul 2023 20:03:00 +0100

I have decided to switch my linux file manager from Dolphin to Thunar and this means transferring the context sensitive menus I have set up through KDE Plasma to using Thunar’s custom actions.

I quickly figured out that I can just modify $HOME/.config/Thunar/uca.xml to add in new Thunar actions, so all I need to do is to firstly work out how to perform the translation from Dolphin to Thunar actions and then how to set up emacs in such a way that would get me to a quick solution.

Dolphin relies on files within $HOME/.local/share/kservices5/ServiceMenus to define the context menus and I have separate files for each MIME type:

AudioMenu.desktop
PictureMenu.desktop
VideoMenu.desktop

Each one has an actions list near the top defining a link to multiple script command definitions throughout the file. So I think all I need to do is to extract out the actions, for example :

Actions=PictureConvert;PictureInfo;PictureRotateLeft;PictureRotateRight;PictureScale;PictureAutoColour;PictureCrush;PictureMontage;PictureRotateFlip;PictureUpscale;PictureGetText;PictureOrientation;PictureCorrect;Picture2pdf

and apply them to the uca.xml file using an example I had already created as a prototype :

<action>
<icon></icon>
<name>PictureConvert</name>
<submenu></submenu>
<unique-id>1688724015024216-1</unique-id>
<command>ServiceConsole PictureConvert %F</command>
<description>PictureConvert</description>
<range>*</range>
<patterns>*</patterns>
<image-files/>
</action>

The ServiceConsole script is just a wrapper around each bash script and lets me choose the terminal, shell and anything else I would like to wrap around:

#! /bin/bash
konsole -e "/bin/bash -c '$*; echo; echo "Finished"; read input'"

Now I know what needs to be done I think I will create a window in emacs on the left containing the Thunar custom action file (uca.xml) and *scratch* on the right and then define a macro to step through each action and apply the script names to the uca.xml file.

I can now extract the Actions list from each file, paste it into the scratch buffer and then forward-word copy to the kill ring in turn and for each script name copy and paste to a new copy of the xml example template.

The only other aspect I need to pay attention to is the transfer of the MIME types to <image-files/> <audio-files/> <video-files/>

There is a <unique-id> set for each action but I think that is more of an internal Thunar Id and I could just copy and paste the existing Id as part of my macro and it still works.

So for a task that I thought would take quite a while and would be convoluted in the end turned out to be pretty trivial and this was mainly due to at first spending some time working out how to translate the configuration files (with a little prototyping) and then applying the transformation using emacs.

These context sensitive menu bash scripts transforming image, video and audio files can also be run off the command line and I can run them in emacs using the dwim-shell-command package. This means that I now have a consistent media transformation set of tools across all my file managers!

I will go into more detail on my use of dwim-shell-command in a future blog post ;)

Dired Duplicate Here Revisited

James Dyer — Tue, 04 Jul 2023 21:13:00 +0100

It is not uncommon for me to want the ability to quickly duplicate a file, especially if I am hacking around and just want a quick snapshot of a working file.

Previously I was using dired in a slightly convoluted manner, namely:

open dired
cursor over the desired item to rename
w (dired-copy-filename-as-kill)
C (dired-do-copy)
paste from the kill ring (yank)
modify the filename as desired
return

But I never actually used this functionality so I think its time for a different approach.

Since I have recently been delving into elisp I thought I would write an interactive function:

(defun my/dired-duplicate-file (arg)
 "Duplicate the current file in Dired."
 (interactive "p")
 (let ((filename (dired-get-filename)))
 (setq target (concat (file-name-sans-extension filename)
 "-old"
 (if (> arg 1) (number-to-string arg))
 (file-name-extension filename t)))
 (if (file-directory-p filename)
 (copy-directory filename target)
 (copy-file filename target))
 )
 )

(define-key dired-mode-map (kbd "C-c d") 'my/dired-duplicate-file)

The function first gets the name of the current file in the Dired buffer using `dired-get-filename`. It then creates a new filename for the duplicated file by appending “-old” to the base filename (i.e., without the extension), followed by the number specified by the `arg` prefix argument, and the original file extension.

For example, if the `arg` argument is 3, and the original filename is “example.txt”, the duplicated filename would become “example-old3.txt”.

The function then checks if the file is a directory using `file-directory-p`. If the file is a directory, it copies the entire directory to the new target directory. If the file is a regular file, it copies the file to the new target file.

The function is interactive, meaning it can be invoked with a key press or command invocation. The function does not return a value.

Could you tell I used ChatGPT to describe this function?, well it was accurate, very precise, but very clinical, possibly useful for the quick documenting of written functions though.

I prefer the following more human approach:

By default a quick flick of the fingers would duplicate rename a file or directory via emacs dired adding the keyword old and potentially a numeric value by means of the universal argument.

Most of the time I just want a quick single backup but for more duplicates there is the option of a quick C-u (adds a 4) and a C-u C-u (a 16) e.t.c

That should do me for now, lets see how I get on!

Cycling Colours in CSS and Other Files

James Dyer — Fri, 23 Jun 2023 11:04:00 +0100

I try and keep a simple colour scheme definition for my web site using some CSS variables:

--theme-fg: #2b2d3a;
--theme-bg: #fffbef;
--theme-alt: #ffa500;

rainbow-mode of course helps to show the colours in situ, but sometimes if I am changing the colour scheme I use list-colors-display and then copy and paste the hex value. But should I use the name instead?, it is tempting as the colour would be very apparent and readable in the CSS file but then it is difficult to just incrementally tweak a hex value to get the colours to look just right. I also like to use orange, well I always seem to revert back to it but I can never remember the hex value.

There is an in-built function in emacs which can help me out with all this called css-cycle-color-format and is bound to C-c C-f

With the point over the colour, potentially three different CSS color formats are cycled, by name (if possible), hexadecimal, and rgb()/rgba().

For example I could cycle through orange as thus:

--theme-alt: orange;
--theme-alt: #ffa500;
--theme-alt: rgb(255, 165, 0);
--theme-alt: orange;

What about a colour / hex value in a non CSS file I hear you say, well although css-cycle-color-format is bound to css-mode-map it can be called for other files and in other modes. For example in init.el calling css-cycle-color-format seems to work so I guess it could just be rebound to any mode-map as desired.

Also if you have a CSS file with a profusion of hex colour values the css-cycle-color-format command could find the name value for you, for example as a test, putting in a colour that is obviously red :

--theme-alt: #ff0000;

cycles to:

--theme-alt: red;

Revert Git Permission Changes On Repository Transfer

James Dyer — Sat, 17 Jun 2023 20:30:00 +0100

I recently reinstalled my laptop and copied across my git repositories from an external backup drive. However most of my repositories were flagged by magit as having been updated mainly with the following issue on multiple files:

old mode 100644
new mode 100755

I found a fix for a single repository on stackoverflow but I have quite a few repositories now, so I wrote the following bash script borrowing the core git diff command fix and then ran it in eshell

#!/bin/bash

LIST="DCIM/Art/Content/ArtAssets
 DCIM/Art/Content/ArtRage
 DCIM/Art/Content/ArtRagePenTool
 DCIM/Art/Content/ArtRageTabletFriend
 DCIM/Art/Content/InfinitePainter
 DCIM/Art/Content/Krita
 DCIM/content
 bin
 publish"

for item in $LIST; do
 echo $item
 cd ~/$item
 git diff -p -R --no-ext-diff --no-color \
 | grep -E "^(diff|(old|new) mode)" --color=never \
 | git apply
done

This is where the integrated nature of emacs can come in useful, although the stackoverflow example was the git diff line I wanted to perform this for each of my repositories and to achieve this I just simply grabbed the Path column output of magit-list-repositories using rectangle-mark-mode and trimmed down using some macros so I could iterate through each repository directory and run the command each time to clean up.

Magit Status To Show Tracked Files

James Dyer — Thu, 08 Jun 2023 11:05:00 +0100

While currently piecing together my git repositories and figuring out which files to commit I am invariably going to have some Untracked files but I also would like to see the Tracked files in magit-status

Well emacs being emacs this can be easily achieved, I added the following to my use-package magit declaration.

:config
(magit-add-section-hook
 'magit-status-sections-hook 'magit-insert-tracked-files nil 'append)

Quickly Deleting Duplicate Blank Lines

James Dyer — Sat, 03 Jun 2023 21:38:00 +0100

I am currently hacking around with my org files and in fact macro removing quite a few unnecessary lines. However this has had the side effect of leaving some significant holes in the form of blank lines. Sometimes just two duplicate blank lines and sometimes more!

I found that I can quickly trim them down by using delete-duplicate-lines and making sure the identical lines must be adjacent argument is set by passing in a C-u C-u prefix.

So the process is:

open the org file
mark-whole-buffer
C-u C-u delete-duplicate-lines

and that’s it!, the key here is the prefix argument otherwise all the blank lines will be deleted which is not what I want.

Of course this method would delete all duplicate adjacent lines and not just the blank ones so I guess you would generally need to be a little careful, but I know I don’t have any of these and if I am not too sure then I can just inspect a git diff.

Insert Unique Log Message

James Dyer — Mon, 29 May 2023 12:00:00 +0100

I had tried to implement a debugging logging/print method myself using macros but hadn’t really achieved the level of elegance outlined in https://xenodium.com/sprinkle-me-logs/

I added a couple of programming modes to the function defined in the post above and have now incorporated it into my workflow:

((equal major-mode 'ada-mode)
 (cons (format "Ada.Text_Io.Put_Line (\"%s: \\([0-9]+\\)\");" word)
 (format "Ada.Text_Io.Put_Line (\"%s: %%s\");" word)))
((equal major-mode 'c++-mode)
 (cons (format "std::cout << \"%s: \\([0-9]+\\)\" << std::endl;" word)
 (format "std::cout << \"%s: %%s\" << std::endl;" word)))

For some reason I always seem to tend to ribald statements within my code, something like poop or some other unsavoury variant, I just need to remember to tidy these up later on!

Oh and I added an old fashioned emacs badge to the top of this blog just for fun! as technically it is kinda true as in this web page and of course as in me as a human 😀

Initial focus in Occur Buffer

James Dyer — Thu, 11 May 2023 20:43:00 +0100

Just a quick one today!

I am finding occur extremely useful, from building an index from my emacs init file to searching through org headers to generally just having my isearch all there in a single window.

However I would rather the cursor would jump to the *Occur* buffer when invoked as it just feels a little more natural, so I added the following:

(advice-add 'isearch-occur :after
 '(lambda (origin &rest args)
 (isearch-exit)
 (select-window (get-buffer-window "*Occur*"))
 (goto-char (point-min))
 ))

Cursor Blinking Rate

James Dyer — Fri, 28 Apr 2023 13:00:00 +0100

Sometimes I can find a blinking cursor distracting and somewhat expectant!, so currently I am favouring a solid non blinking cursor while still being able to easily locate my cursor using hl-line-mode

I have tried beacon and pulsar in the past but have found that a simple line highlight nicely serves my purpose.

This however led to a weird issue at work with my emacs setup and although I am not quite sure why it is happening (although I have my theories) I have found a workaround.

As at home I am always tinkering with my emacs init file and I think at some point I decided to turn off cursor blinking. This coincided with a new virtual machine setup and hence a new emacs install. At that point I started to notice that sometimes the emacs window wouldn’t refresh until I either gave it some keyboard input or strangely I just wiggled my mouse :)

I could reproduce this issue by restarting emacs from a clean start (cleaning out buffers and the desktop file) and switching immediately to a permanent register pointing to a file. Also I would notice that sometimes when I dired-jump’d I would have to tap a key to get the emacs window to refresh.

After a period of trial and error I narrowed the culprit down to :

(blink-cursor-mode -1)

When I turned on a blinking cursor there would be no such emacs refreshing issue.

I came up with a theory that in a setup involving VM Machines/X11/linux window manager/compositor/emacs/host graphics driver/and so on, there may be a graphical optimization that requires a specific event to occur for an emacs window to refresh. It’s possible that the reason everything works smoothly with a blinking cursor is because the cursor is constantly disappearing and reappearing, which triggers a refresh event.

So…. the question is how do I preserve a non blinking cursor and still get an emacs window to consistently refresh?, well I dug into the blinking cursor options and set the following:

(blink-cursor-mode 1)
(setq blink-cursor-interval 0.001)
(setq blink-cursor-blinks 1)

A single initial blink of the cursor would trigger a reliable display refresh but would be imperceptible to the human eye thus providing a perceived non blinking cursor!

Oh and a final thing, has anyone noticed that by default an emacs cursor blinks but 10 times and then stops?, I’ve got to say it was only when I was digging around the blink-cursor variables and actively scrutinising the cursor blink behaviour that I noticed. I had assumed that it just kept blinking forever!

Imenu Indexing My emacs Init File

James Dyer — Fri, 14 Apr 2023 14:34:00 +0100

After implementing my simple occur indexing in my last post :

Indexing My Emacs Init File

A suggestion was made to put this into an imenu.

I thought that was rather a good idea and it would also give me the opportunity to explore imenu

I came up with the following to add to the emacs init file :

(add-hook 'emacs-lisp-mode-hook
 (lambda ()
 (setq imenu-sort-function 'imenu--sort-by-name)
 (setq imenu-generic-expression
 '(
 (nil "^;;[[:space:]]+-> \\(.*\\)$" 1)
 ("defun" "^.*([[:space:]]*defun[[:space:]]+\\([[:word:]-/]+\\)" 1)
 ("use-package" "^.*([[:space:]]*use-package[[:space:]]+\\([[:word:]-]+\\)" 1)
 )
 )
 (imenu-add-menubar-index)))

which produces the following:

I thought for good measure I would also add in some menus for defuns and use-package declarations (just for fun!) with my main defined sections forming the top level due to the MENU-TITLE being set to nil in the imenu-generic-expression variable.

This implementation has the added benefit of integrating nicely into the local completion system. For example I use vertico and running imenu calls up the defined sections in the mini-buffer and as an extra benefit running consult-imenu does its consult thing to quickly step through the sections or of course to complete. As I have defined section names for defun and use-package the completion search can search on these too to quickly narrow things down.

I had never looked into imenu before and it was quite an interesting learning experience and in fact I went all the way to defining my own imenu-create-index-function where I can create my own alist index in any way I want to, that was until I found a more simple method!

Indexing My Emacs Init File

James Dyer — Wed, 12 Apr 2023 14:36:00 +0100

Since I keep all my emacs configuration in a single .emacs file and in a hyper organised manner it means I have my init file split into different sections, for example :

platform
packages
mail
calendar
completion
save-desktop
keys
modes
setqs

with each section delimited by a comment of the form:

;;
;; -> platform`
;;

Now I am using occur more often, then why not write a function to produce a nice little Occur buffer containing an index of my init file sections, as thus:

(defun my/index ()
 (interactive)
 (beginning-of-buffer)
 (occur ";;[[:space:]]->"))

I avoided the self index reference by explicitly using the [:space:] variant for the occur regex.

and this gives me the following:

The selection of each item takes me to the relevant section of my emacs configuration and as I have f8 bound to next-error I can easily step through each section if I want to.

Sorting Org Tags using Org Mode!

James Dyer — Fri, 07 Apr 2023 16:04:00 +0100

Well as always a little more time with emacs a little feedback and then finding more about org I have now figured out (I think) how I can better sort tags in an org file. In my previous post:

Sorting Org Tags

I made the following comment:

I had assumed that org-mode came with the built-in ability to sort tags but I couldn’t find any evidence of this

Well as it turns out there is evidence of this! and it takes the form of:

(setq org-tags-sort-function 'org-string-collate-greaterp)

This is tied into C-c C-q (org-set-tags-command) of which I hadn’t yet discovered but now I think I shall bring into my muscle memory. I had previously just been manually adding tags!

Further interwebs hunting and I came across the following function:

(defun my/org-sort-tags ()
 "On a heading sort the tags."
 (interactive)
 (when (org-at-heading-p)
 (org-set-tags (sort (org-get-tags) #'string<))))

which more concisely accomplishes my original intention and will work when the cursor is anywhere on an org heading and therefore a macro or presumably an org-* type iterator would neatly take care of the whole file for me.

Although I went down a little rabbit hole I found a few things down there, elisp improvement, digging more around org-mode and bewilderingly wondering where my journey will end. Of course with emacs it never will, my little head will just peep out at the daylight sun every now and then but my little noggin will be wiser and more proficient 😃

Sorting Org Tags

James Dyer — Sat, 01 Apr 2023 12:55:00 +0100

I use a package called org-rainbow-tags which adds random colours to org tags to provide a consistent colour between identical tags. This helps to identify common tags throughout the file but has the side effect of emphasising the lack of my coherent tag ordering.

I would like to order the tags consistently, just for my own peace of mind! 😀

I had assumed tkhat org-mode came with the built-in ability to sort tags but I couldn’t find any evidence of this so I decided to create a method using my own function. My preferred default method is in descending order as I commonly use a year tag which I would always like to be on the right hand side.

Just select the region containing the tags and run my function passing in the universal argument if you fancy ordering the other way!

(defun my/sort-org-tags-region (beg end &optional reversed)
 "In active region sort tags alphabetically in descending order.
 With prefix argument REVERSE order."
 (interactive "r\nP")
 (unless (region-active-p) (user-error "No active region to sort!"))
 (let* ((str (s-trim (buffer-substring-no-properties beg end)))
 (wrd (split-string str ":" t " "))
 (new
 (concat
 ":"
 (s-join ":" (sort wrd (if reversed #'string< #'string>)))
 ":")
 )
 )
 (save-excursion
 (goto-char beg)
 (delete-region beg end)
 (insert new)
 )
 )
 )

Trimming ArtRage Playback Scripts using Emacs

James Dyer — Tue, 21 Mar 2023 14:30:00 +0000

Emacs isn’t my only obsession, I like to create digital art and for that I use ArtRage. The interesting thing about ArtRage is that each brush stroke or editing action can be recorded in a text file or script for later playback. I use this facility for creating time-lapses.

The ArtRage manual describes the following:

Script Files
ArtRage scripts are simple Unicode UTF16 text files which can be edited using Notepad, Notepad+++, TextEdit, or any similar program

“similar program”?! now let me think….. what do I have available :)

For a nice clean time-lapse ArtRage now has the ability to filter out the rest of the UI elements and leave the canvas fixed in the center of the screen. For the most part this works very smoothly however sometimes the recording hasn’t quite registered some strokes properly or some reference files have moved, in this case I may get an error such as:

At which point it is time to break out emacs and delve into the recorded text script file. For a typical piece of art the script can get quite large, for my last portrait it was 174M with 605012 lines. How does emacs handle this?, well it had no problem and opened it in a split second!

I think to resolve this current issue around ReferenceImageXForm I am just going to remove all occurrences as for a time-lapse playback I don’t usually want to show the references anyway.

First of all lets isearch for ReferenceImageXForm, now that I have isearch-lazy-count turned on it gives me 1/36 in the minibuffer. Lets just step through each one and remove the whole line.

Also I think I would like to remove the initial reference image load which starts off as:

Wait: 33.293s EvType: Command CommandID:
LoadReferenceImage Idx: 0 Reference Image: {

and then has many lines of image data and then finishes with an enclosing brace. Of course this is easy to remove in emacs by leveraging:

(kill-sexp &optional ARG INTERACTIVE)
Kill the sexp (balanced expression) following point.

now a quick save and playback and the timelapse runs perfectly.

I remember a while ago when I was not quite aware of the capabilities of emacs and I was more Windows bound I had to look for specific text editors that could handle large files and then save them in the requisite Unicode UTF16 format. They were slow, it was a hassle, I couldn’t define any macros e.t.c, but emacs just does this out of the box!

Maybe I should petition the ArtRage team to reference emacs in their documentation!

Editing org files on an Android device - Part 1

James Dyer — Sun, 12 Mar 2023 21:08:00 +0000

Now that there is a build for emacs on Android I thought I would try and develop an emacs workflow between my Galaxy Note 8 / Galaxy Tab S7+ and my linux laptop.

At the moment I am using Markor on my phone and this serves my needs adequately but of course I am missing that org file support.

My current process involves syncthing to push my org files around my laptop / phone and tablet. I also push other things that are regularly backed up and this does include my .emacs config file.

So the relevant files are already present on my device the next thing to do is to install emacs from F-Droid and grant emacs file permissions.

My phone is running Android version 9 and my tablet version 13 so the method to get permissions set up for Emacs was slightly different in each case.

On my phone from the settings I selected Apps -> top right menu (App permissions) -> Storage -> Emacs to On

On my tablet from the settings I selected Apps -> top right menu (Special access) -> All files access -> Emacs to On

Next up is to set up my configuration file, in this case I am going to create a symbolic link using dired. First of course is to run up emacs and then navigate to my syncthing’d .emacs file which in my case is in the following location:

/storage/emulated/0/DCIM/Linux

The android emacs menu bar is quite responsive and the menu appears in a nice large touch friendly font so I can just File -> Open Directory… at which point an on screen keyboard pops up and I can input the path.

Note : Something I discovered early on was that because I have KDE Connect installed across all my devices and Clipboard sync is turned on it means that the clipboard is shared between devices. This means that anything that is copied from within emacs on my laptop appears on my phone or tablet, so I could just type out the path on my laptop, copy it to the kill ring and it appears on the Samsung Keyboard clipboard field ready to paste into emacs!

Now the path has been input dired shows the directory containing all my files including my .emacs file. Now I select the line containing the file (yes, using my finger!!) then from the top menu : Operate -> Simlink to… and input the following:

/data/data/org.gnu.emacs/files/.emacs

Now restart emacs or maybe Emacs-Lisp -> Evaluate Buffer

When I first attempted this my default .emacs gave a prodigious number of errors and I realised that for the moment android emacs doesn’t have the ability to download packages from melpa or elpa. Not too much of a problem for me though as my default config is tending towards vanilla anyway so for the moment I decided to create a purely android version of my .emacs config by stripping out everything I didn’t think I needed with an eye on creating a generic version across not only android but windows too. Currently I have a few (when (string-equal system-type "windows-nt") and for android I just need something similar but with android as the defining string.

Technically just setting the storage permissions for emacs on my device would have been enough to open an org file and edit it, but now I have a symbolic link to my .emacs config and it is synched to all my devices it means I now have the ability to modify it anywhere and although I currently have an android specific version it won’t be too long before I have a single generic config for all my devices / operating systems.

The next step will be to find an on-screen keyboard to fit a good emacs editing workflow - a sneak peek below of Keyboard Designer but that will be for part 2!

Replacing deadgrep with consult-ripgrep

James Dyer — Wed, 08 Mar 2023 21:08:00 +0000

I have been evolving my way through many differing ways of grepping recently from standard built-in greps to a few ripgrep front ends until I finally settled on deadgrep

I am currently an ivy user but as everyone seems to be talking about vertico and the associated completion stack I thought I would give it a try and therefore consult-ripgrep to see it can improve on my deadgrep setup.

Previously I have created a couple of wrappers around deadgrep:

(defun my/deadgrep ()
 (interactive)
 (if (equal major-mode 'dired-mode)
 (setq search-term
 (read-from-minibuffer "Search : "))
 (setq search-term
 (read-from-minibuffer "Search : " (thing-at-point 'symbol)))
 )
 (deadgrep search-term home-dir)
 )

(defun my/grep ()
 (interactive)
 (if (equal major-mode 'dired-mode)
 (setq search-term
 (read-from-minibuffer "Search : "))
 (setq search-term
 (read-from-minibuffer "Search : " (thing-at-point 'symbol)))
 )
 (deadgrep search-term)
 )

As a universal argument was passed to deadgrep which had a side effect of initially pausing the search, this meant I split my grepping between S-f12 and M-f12 one for a project grep and one for a local directory grep.

As part of trying out consult-ripgrep I think I would like to rewrite the functions above and I would want a quick and simple method to revert back to using deadgrep.

I settled on the following:

(defun my/project-root ()
 (interactive)
 "Guess the project root of the given FILE-PATH."
 (let ((root default-directory)
 (project (project-current)))
 (when project
 (cond ((fboundp 'project-root)
 (setq root (project-root project)))))))

(defun my/grep (arg)
 (interactive "p")
 (if (equal major-mode 'dired-mode)
 (setq search-term
 (read-from-minibuffer "Search : "))
 (setq search-term
 (read-from-minibuffer "Search : " (thing-at-point 'symbol)))
 )
 (if (> arg 1) ;; if C-u has been activated
 (consult-ripgrep default-directory search-term)
 (consult-ripgrep (my/project-root) search-term)))
;; (progn
;; (setq current-prefix-arg nil)
;; (deadgrep search-term default-directory)
;; )
;; (deadgrep search-term (my/project-root))))

To switch between deadgrep / consult-ripgrep I just need to uncomment / comment in and out the relevant bits and then re-evaluate.

As you can see I created a local function to find the project root directory if one exists and to then pass the result to the deadgrep / consult-ripgrep command meaning that they will both perform identically from a search directory perspective.

Note how I overcame the pass-through of the universal argument to deadgrep by just resetting the current-prefix-arg after I had already used the universal argument logic within the function.

I can now free up my original M-f12 binding which searched from the local default-directory as I can C-u to the S-f12 binding.

I’m not too sure about consult-ripgrep yet but the setup above gives me the following benefits:

A common local find project root function that might become useful for future functions
Flexibility with the universal argument meaning I could pass in multiple universal arguments or maybe even a numeric argument for enhanced functionality
Able to quickly switch between ripgrep implementations by commenting / un-commenting
Frees up a keybinding

Using Macros to Help Code Debugging

James Dyer — Thu, 02 Mar 2023 20:08:00 +0000

Often I find myself requiring the most rudimentary of methods of debugging and that is to push text to standard output from within a running executable to indicate the logical structure of a program.

This situation may come about if I can’t debug a dll or generally actually stopping a program to debug creates an “observer effect”

Sometimes the logical structure can be somewhat complex consisting of a plethora of if statements and nested for loops, e.t.c and may take me a tedious while to apply the necessary debug statements. But emacs macros can speed up this process drastically!

I often code in Ada and the text to stdout mechanism is generally something like:

ada.text_io.put_line("Yes Ada is a language!");

My macro starts with a simple search for blank lines using C-M-s (isearch-forward-regexp) for the regex ^$

Next I would like to have a unique string for each debug statement and this can be accomplished by using (kmacro-insert-counter) via C-x C-k C-i

For example to debug the following dummy code:

with Ada.Text_Io;
procedure Ada_Main is
Ftt : Boolean := True;
Count : Integer := 0;
procedure Call_Routine is
begin
null;
end Call_Routine;
procedure Call_Another_Routine is
begin
null;
end Call_Another_Routine;
begin
Ada.Text_Io.Put_Line("Program Starting");
if Ftt then
Call_Routine;
else
Call_Another_Routine;
end if;
while Count < 3 loop
Call_Routine;
Count := Count + 1;
end loop;
Ada.Text_Io.Put_Line("Program Finished");
end Ada_Main;

which just outputs the following:

Program Starting
Program Finished

To debugify this simple program, I can record a macro and perform the following steps:

perform (isearch-forward-regexp) for ^$
type in my debug output statement - in this case an Ada one
insert an incremented counter
complete the debug statement.

On a macro repeat I will now have a unique text_io for each blank line giving me an indication of the code path. I can kick off my macro from any point in the program and stop at any time hence below:

with Ada.Text_Io;
procedure Ada_Main is
Ftt : Boolean := True;
Count : Integer := 0;
procedure Call_Routine is
begin
null;
end Call_Routine;
procedure Call_Another_Routine is
begin
null;
end Call_Another_Routine;
begin
Ada.Text_Io.Put_Line("Program Starting");
Ada.Text_Io.Put_Line("##1");
if Ftt then
Call_Routine;
else
Call_Another_Routine;
end if;
Ada.Text_Io.Put_Line("##2");
while Count < 3 loop
Ada.Text_Io.Put_Line("##3");
Call_Routine;
Ada.Text_Io.Put_Line("##4");
Count := Count + 1;
Ada.Text_Io.Put_Line("##5");
end loop;
Ada.Text_Io.Put_Line("##6");
Ada.Text_Io.Put_Line("Program Finished");
Ada.Text_Io.Put_Line("##7");
end Ada_Main;

and running now gives me:

Program Starting
##1
##2
##3
##4
##5
##3
##4
##5
##3
##4
##5
##6
Program Finished
##7

Which may help me to figure out what is going wrong with my program (although in this case nothing was really going wrong!)

For large complicated source code to have such a fast mechanism such as this can be very useful and it is amazing at just how quickly a program fault can be identified by using this simple and almost primordial method.

This of course could be improved in many different ways, for example to not rely on blank lines and possibly force insert debug statements based on semi colons or maybe to decipher the syntactical structure (tree sitter?) and insert the debug statements in a more coherent and comprehensive manner. But this is only a rudimentary quick method to roughly locate a programs issues and it is good enough for me.

Moving Away From Deft

James Dyer — Wed, 22 Feb 2023 20:33:00 +0000

As the title says, it is with a heavy heart that I have decided to move away from deft. There are a few reasons for this:

All files I am interested in quickly locating and editing are now orgified (turned into org files)
All these files are located in a single directory
All these files have a sensible naming convention indicating the contents
I am now much more familiar with dired
I didn’t ever use the deft facility for creating new files, I prefer to use dired
I didn’t ever need to incrementally filter / search as I can use emacs / dired for this
Deft took a couple of seconds to initially load
My deft configuration was becoming a little bloated and I wanted to use vanilla emacs where I could; see below for my former deft configuration:

(use-package deft
 :bind ("C-c d" . deft)
 :commands (deft)
 :config (setq deft-text-mode 'org-mode
 deft-use-filename-as-title nil
 deft-auto-save-interval 0
 deft-use-filter-string-for-filename t
 deft-extensions '("org")
 deft-default-extension "org"
 deft-time-format "%Y-%m-%d %H:%M:%S"
 deft-new-file-format "%Y-%m-%dT%H%M%S"
 deft-strip-summary-regexp "\\([\n]\\|^#\\+.+:.*$\\)"
 deft-recursive t))

It is time to move onto something a little more simple, namely:

(setq deft-directory (concat home-dir "/DCIM/content"))
(bind-key* (kbd "C-c d") (lambda()(interactive)(dired deft-directory)))

and yes I decided to keep the venerable name of deft in memoriam.

I think this is an example of over time learning that emacs has a lot of what you want already built in and with org mode it gently nudges you to organise files in a more coherent manner leading to a more simple agnostic digital way of life.

Commenting Un-commenting

James Dyer — Wed, 15 Feb 2023 20:57:00 +0000

After watching an interesting video by EmacsElements regarding commenting and un-commenting I have to say that I wholeheartedly agree. I really don’t like the way comment-dwim works and made me think back to one of the first elisp functions I commandeered from the interwebs :

(defun my/comment-or-uncomment ()
 "Comments or uncomments the current line or region."
 (interactive)
 (if (region-active-p)
 (comment-or-uncomment-region
 (region-beginning)(region-end))
 (comment-or-uncomment-region
 (line-beginning-position)(line-end-position))))

and it is a command that I constantly use and had forgotten that it isn’t part of the emacs default functionality from a M-;

Simple Flexible Scrolling

James Dyer — Wed, 08 Feb 2023 21:21:00 +0000

I have written before about smooth scrolling using good-scroll and how I managed to find a semi satisfactory way of centering my cursor after a single scroll which meant I would then have a minimal amount of subsequent line movement to get to the line I want.

However, I have since returned to a simple concept, more of a basic scroll-[up/down]-command which in its bare form scrolls a whole page. Now for me this is too much and I still want to have the ability to control how many lines I scroll which will still indicate to my brain that text is scrolling so I can still take in the overall form of a file.

I initially returned to my simple scrolling functions:

(defun scroll-up-some ()
 (interactive)
 (scroll-up-command (window-some-height)))

(defun scroll-down-some ()
 (interactive)
 (scroll-down-command (window-some-height)))

(defun window-some-height ()
 (max 1 / (1- (window-height(selected-window))) 4))

which leveraged the number of lines as an argument to the scroll-[up/down]-command

I would however really like to simplify and still allow some centering, I therefore created the following bindings:

(bind-key* (kbd "M-j")
 (lambda()
 (interactive)
 (next-line (/ (window-height) 12))
 (recenter)))

(bind-key* (kbd "M-k")
 (lambda()
 (interactive)
 (previous-line (/ (window-height) 12))
 (recenter)))

The only issue I have with this implementation is that when I move to the end of a file and scroll upwards the first scroll recenter is a bit jarring as moving to the end-of-buffer is not typically centred and has any number of blank “lines” below it. Moving to beginning-of-buffer has no such issue as the cursor moves right to the top and subsequent scroll down recenters do not activate any scrolling until the cursor is past the center point of the window.

This issue however is easily fixed by:

(bind-key* (kbd "M->")
 (lambda()(interactive)(end-of-buffer)(recenter)))

which forces an initial recenter whenever an end-of-buffer keybinding is activated, meaning that the first scroll upwards is now seamless!

How to Display Google Calendar

James Dyer — Sat, 04 Feb 2023 13:20:00 +0000

Emacs is subsuming me! I have managed to get email up and running using mu4e and rss using elfeed and image viewing with image-dired

Next up is some form of calendar integration!

Although I use Google Calendar I don’t rely on any google apps directly; an android app called Simple Calendar is adequate for my needs and enables the thing I cherish most of all (except emacs of course!) and that is the ability to produce an offline copy. It can export to an ics file, and I have developed a habit of exporting to an offline file every time I update my calendar. This means that I have some exported calendar files lying around, including of course the most recent one.

Initially I attempted to use org-gcal which potentially enables a two way communication with Google Calendar through their API, but I got lost in the setup and of course this is Google, at some stage it is likely they will either change their API / remove it / or charge for it.

Anyway, do I really need to modify my calendar from within emacs?, I am quite comfortable using Simple Calendar on my phone and if I really need to add calendar entries from my laptop then I always have Thunderbird as a backup.

So I may just be in a very fortunate position regarding an adequate level of emacs calendar integration :

I only require read only
I have an up-to-date ics file available

I created the following function which opens up a nicely formatted calendar using the packages calfw and calfw-cal (and they didn’t require any additional setup).

(defun my/calendar ()
 (interactive)
 (setq tmp-file (concat home-dir "/DCIM/Backup/tmp.org"))
 (delete-file tmp-file)
 (when (get-buffer (file-name-nondirectory tmp-file))
 (kill-buffer (file-name-nondirectory tmp-file)))
 (setq last-ics
 (car (directory-files
 (concat home-dir "/DCIM/Backup")
 'full "\.ics$" #'file-newer-than-file-p)))
 (icalendar-import-file last-ics tmp-file)
 (cfw:open-diary-calendar)
 (when (get-buffer (file-name-nondirectory last-ics))
 (kill-buffer (file-name-nondirectory last-ics))))

and produces a calendar of the form:

I could import everything directly into my diary-file but I decided to be a little more flexible and potentially allow for multiple calendars by setting an include directive in my diary file as thus:

#include "~/DCIM/Backup/tmp.org"

The key to the my/calendar function is to pull in the most recent ics file and call the built in icalendar-import-file to convert / import the ics data into my diary file. The cfw packages will then take care of the rest. The other parts of the function are just tidying up various buffers and files to make things a little cleaner.

One little wrinkle I discovered and didn’t necessary solve to a satisfactory level was when I first call up cfw:open-diary-calendar the calendar didn’t resize correctly to fit the window, a second call however seemed to fix this and with no overhead.

One final addition was the following:

(add-to-list 'display-buffer-alist
 `(,(rx(or "Calendar"))
 display-buffer-in-direction
 (direction . right)
 (dedicated . t)
 (window . root)
 (window-width . 80)))

Which gives me greater control of where the calendar window is opened

Using ripgrep within Projects

James Dyer — Tue, 24 Jan 2023 21:07:00 +0000

Given my recent forays into the world of grepping in emacs using deadgrep (and hence ripgrep) and my use of find-file-rg which feeds into my current completion system of ivy I think the next step is to try to set up a project and to see if I can gain any advantages in my workflow.

I am not yet going to dive head first into projectile but dangle a tentative pinky into the deep project pools of the built in project system, namely EDE (Emacs Development Environment).

As I have mentioned before I typically would only be working within a single directory hierarchy, hence my previous deadgrep enhancement of using a defined setq home-dir variable, but I think it might be an enhancement if I could leverage deadgreps use of projects; for example, wandering around the deadgrep code I found the following:

(defun deadgrep--project-root ()
 "Guess the project root of the given FILE-PATH."
 (let ((root default-directory)
 (project (project-current)))
 (when project
 (cond ((fboundp 'project-root)
 ;; This function was defined in Emacs 28.
 (setq root (project-root project)))
 (t
 ;; Older Emacsen.
 (-when-let (roots (project-roots project))
 (setq root (car roots))))))
 (when root
 (deadgrep--lookup-override root))))

as far as I can tell the default-directory is the current directory of the buffer which can be displayed by M-x pwd but it is the (project-current) that I am more interested in.

A quick investigation and it seems I need to turn on global-ede-mode and then run ede-new in the top level directory of my prospective project. This results in the creation of a Project.ede file containing some project information allowing the setting up of a collection of source files and instructions on how to build them. For the moment I’m not too interested in building anything, but more on how to trigger deadgreps project logic by enabling this directory hierarchy as a project.

As part of creating this project file it seems ede-project-directories has also been added to my init file and an extra menu has appeared on the menu bar called Development

Is this all I need?, well lets evaluate the following in the top level folder:

(project-current)

I seem to get a long list of project information, including the project top level directory. Moving down the directory hierarchy and reevaluating the same expression gives me the same directory!

So I am assuming that in my/deadgrep bespoke wrapper, if I now replace:

(deadgrep search-term home-dir)

with:

(deadgrep search-term)

if I create a project in my former home-dir directory location then my former functionality will have been preserved but with the added flexibility of being able to define other project locations, and also apparently subdirectories! this is actually pretty neat :)

Now I have defined a rudimentary project and seems to work well with deadgrep will it work well with my other favourite ripgrep wrapper, namely find-file-rg? Well there does seem to be some code to accommodate projects too, namely:

(let* ((dir (if current-prefix-arg
 (find-file-rg--read-dir)
 (or (let ((project (project-current)))
 (when project
 (if (fboundp 'project-root)
 (project-root project)
 (cdr project))))

and yes, it works!, so anywhere I am within the hierarchy of a project I can call up a list of files fed from ripgrep –files into ivy and complete as normal.

As a bonus find-file-rg allows the passing of a universal argument and a current-prefix-arg check enables the navigation to any directory.

In summary then, I can now define a project, I can grep throughout the project from any file / directory within that project and I can pull up a list of files within the project all leveraging the power of ripgrep through deadgrep and find-file-rg!

More flexible grepping with deadgrep

James Dyer — Fri, 20 Jan 2023 00:00:00 +0000

I seem to be grepping a lot recently and I think the way I use deadgrep can be improved a little.

Currently deadgrep defaults to a recursive ripgrep from the default-directory which is generally the current directory of the buffer, but I find that by default I tend to mostly want to grep from a top level directory (yes I know, almost like a project!).

I would like to have a typical Find All References type of functionality from my grepping and not to rely on xref as I will not necessarily ever know if any xref functionality is supported for any file that I am working on and for the moment I am not using any connection to an LSP server. I would like a simple generic process that can be used across all files and I think deadgdrep can help me out with this.

I would like to bind to S-f12 to grep from the “project” top level with the search set to whatever string is under my cursor; this should enable a quick workflow involving jumping around files within the top level directory structure bouncing back and forth between the deadgrep buffer.

I have chosen the binding of S-f12 for consistency across IDEs as I am often required to use VSCode and Visual Studio for work.

In addition I would like to replace my usual local directory grepping where I use grep with deadgrep for a more unified approach.

So I created the following two functions:

(defun my/deadgrep ()
 (interactive)
 (if (equal major-mode 'dired-mode)
 (setq search-term
 (read-from-minibuffer "Search : "))
 (setq search-term
 (read-from-minibuffer "Search : " (thing-at-point 'symbol)))
 )
 (deadgrep search-term home-dir)
 )

(defun my/grep ()
 (interactive)
 (if (equal major-mode 'dired-mode)
 (setq search-term
 (read-from-minibuffer "Search : "))
 (setq search-term
 (read-from-minibuffer "Search : " (thing-at-point 'symbol)))
 )
 (deadgrep search-term)
 )

home-dir as you might guess is where my top level directory resides.

I came to realise that when I am in a dired buffer I don’t actually ever want to grep with the string under the cursor (which of course would most likely be a file or directory) but only when I am in a file.

I toyed around with the idea of having a single (interactive “p”) function so it would accept a prefix command and then perform the following kind of logic:

((equal current-prefix-arg nil) ; no C-u
 (do top level grep))
((equal current-prefix-arg '(4)) ; C-u
 (do local grep))
((equal current-prefix-arg 1) ; C-u 1
 (do some other grepping))

however this had the unintended consequence of pushing through the prefix command to deadgrep and therefore it would not start immediately but wait for user interaction. I couldn’t see a way round this so had to split my grepping into both a S-f12 and M-f12 for each function call; not much of a big deal.

As I am just running a single deadgrep instance using:

(setq deadgrep-max-buffers 1)

I also needed to add the following as I will always want to kill the current process if I am starting a new one.

(setq kill-buffer-query-functions nil)

Using org-copy-visible in dired

James Dyer — Sun, 15 Jan 2023 00:00:00 +0000

Just a quick one.

Often it seems I need a copy of a list of files / directories in plain text without any gubbins such as a path, permissions, date and all those shenanigans, basically basenaming; for example:

So how can I achieve this in emacs? I would really prefer to use dired somehow rather than shell / ls (which was my first thought)

Below is my typical dired listing:

drwxr-xr-x 4 4.0K Jan 15 19:35 Backup
drwxr-xr-x 3 4.0K Jan 14 19:33 Camera
drwxr-xr-x 22 4.0K Jan 15 19:01 content
-rw-r--r-- 1 65 Dec 31 16:34 .directory

Rectangle marking first came to mind but the paste seems to have a weird format and strangely inserts the text.

So I came up with the following process:

In dired, select ’(’ dired-hide-details-mode which toggles off all the details and gives:

Backup
Camera
content
.directory

This looks very promising and surely a simple M-w (kill-ring-save) will work?. It doesn’t work. It still copies the full details :(

However if org-copy-visible is used it does the same as in org mode in that it only copies the visible parts of the region. I had no idea that functions from one mode can be used in another!

Creating Album Art Thumbnails for EMMS

James Dyer — Fri, 13 Jan 2023 00:00:00 +0000

I have been looking for a music player on Linux for a while now but haven’t really settled on one; I have simple requirements:

A view showing album art
An easy way to play random tracks
A quick method to skip a track

To date I have only been considering players with a graphical front end but it always seems a hassle to, open the program, look for some music, figure out how the shuffle and play work; and then what if I don’t like the current track playing?, my laptop isn’t really set up to quickly skip the track.

Now I am delving further into the integrated environment of emacs I thought I would see what was on offer.

A little research and I settled on EMMS

I will go into a deeper review after I have used it for a few months but mainly for this post I wanted to share a quick bash script I created to allow album art to be shown in EMMS.

By default EMMS looks for a cover.jpg file in the current music directory. My collection is neatly split into directories for each album with album art embedded into each mp3 track. This has given me the opportunity to write a bash script to automate the creation of these cover.jpg files.

The script is as follows:

#!/bin/bash
DIRS=$(find "$HOME/MyMusicLibrary" -type d -printf '%p;')

export IFS=";"

for dir in $DIRS; do cd "$dir" files=(*) if [[ ${files[0]: -4} == ".mp3" ]]; then echo $dir ffmpeg -hide_banner -loglevel panic -stats -y \ -i "${files[0]}" -an -c:v copy "$dir/cover.jpg" convert -resize 120x120 "$dir/cover.jpg" "$dir/cover.jpg" fi done

Of course change the "$HOME/MyMusicLibrary" to your music library location and then in the emacs init file add the following:

(setq emms-browser-covers 'emms-browser-cache-thumbnail-async)

and this is an example of the result (my music collection is larger than this!):

Dired Duplicate Here

James Dyer — Tue, 10 Jan 2023 00:00:00 +0000

dired can do most things for me especially now I have my DWIM image conversion scripts working and image-dired configured to my liking.

However sometimes I do just prefer using a GUI file manager; for example, drag and drop, image file preview e.t.c.

I am currently using the Dolphin file manager on KDE and one context menu service that I have enabled and use often is the Duplicate Here function. It is often that I like to back up a file / directory to a quick temporary directory especially when I am hacking around with the original and on windows it is often that I copy and then paste with Windows automatically applying a Copy to the original name. Dolphin does something similar but applies a (1) when it suggests a new name.

Enough rambling!, simply I would like to reproduce this functionality in dired but with the improvement of not adding in spaces to the new name and being able to define any unique naming convention I like.

So in dired to achieve this, simply:

open dired
cursor over the desired item to rename
w (dired-copy-filename-as-kill)
C (dired-do-copy)
paste from the kill ring (yank)
modify the filename as desired
return

pretty simple and uses all standard dired functionality and of course can be converted to a macro for a certain reproducible naming conventions and then maybe an attachment to a keybinding.

Note that it might be worth adding the following to your emacs init file so no confirmation will be required when copying directories:

(setq dired-recursive-copies 'always)

Merging org files for Hugo static site

James Dyer — Mon, 09 Jan 2023 00:00:00 +0000

I have just started the process of reducing the number of org files I maintain for my web site. I now have a greater understanding of how Hugo handles these files and I think can both simplify and make them more flexible.

Hugo is my static site generator of choice and although it supports org files directly I prefer to generate to a markdown file as an intermediate step using a file by file evaluation of org-hugo-auto-export-mode. This means that each org subtree I modify automatically generates an md file to a defined folder dictated by #+hugo_section in the org header.

For example, I have a few org files that generate my art blog; one for videos, finished art, galleries and now AI. Each org file has a single header #+hugo_section defining the destination export folder. I think now I would like a bit more flexibility with the ability to push a subtree to a folder of my choosing so any extra sections can more easily be added. Plus, if I merge I would only have to maintain a single org file (although a larger one!).

To achieve this I will have to add an extra property to the existing org drawer for each subtree using :EXPORT_HUGO_SECTION: and then to adapt my org-capture templates.

Now of course to add the subtree property emacs can certainly help me out.

I would like to insert typically a drawer property line for each subtree such as:

:EXPORT_HUGO_SECTION: art--all

However of course things are not quite so simple. It seems that some subtrees already have such property lines even though the destination folder is ultimately the same as #+hugo_section in the header (another good reason to tidy up)

So rather than a simple isearch to an ever present subtree anchor point (for example :EXPORT_FILE_NAME:) and then the insertion of the new line I will need to take into account those subtrees that already have :EXPORT_HUGO_SECTION: and not insert a line.

I considered edit mode in multi-occur but as far as I can tell it doesn’t work too well when new lines are inserted.

deadgrep (ripgrep) also has similar functionality and will also show context around the search point which can be also edited in a similar manner to multi-occur but all this is starting to feel too fiddly and I am starting to spend too much time investigating this!

The grep/occur to edit buffer approach can work well in certain situations but this is a little more complex involving a small amount of logic. At this stage the same thought always occurs to me and I really wish it would occur to me earlier.

what about macros?

The isearch technique won’t quite work (as explained above), but what about isearch-regexp?

As the properties are always in the same order I could just insert the :EXPORT_HUGO_SECTION: line if I find the following regex:

:EXPORT_FILE_NAME:.*
:EXPORT_HUGO_LASTMOD:

Note that the carriage return is achieved by C-q C-j

Incorporate this into a macro and the cursor will only move to a point that doesn’t have a :EXPORT_HUGO_SECTION: line and hence I can then insert and then repeat until my org file is suitable amended!

Quick Bash Scripts Augmenting Org Files

James Dyer — Wed, 21 Dec 2022 00:00:00 +0000

This post isn’t strictly about what can be achieved within the emacs ecosystem but what can be achieved outside it while still binding to the workflow principles of org mode.

I have yet to convert to any of the internal shells/terminal emulators within emacs, I have continued to Control-Alt-T (C-M-t) term my way around linux; although this is becoming less frequent due to my greater proficiency with dired

As my org journey evolves I have now realised that I have two files I rely on for my quick capturing needs. When an idea pops into my head I am usually emacs bound anyway so org-capture is always there for me. But what if I am alfresco?, and maybe, just maybe I am in a terminal! Well I could quickly switch to emacs as it is 99% likely to be already running, but what if it is not?!

I could open emacs and then do my thing but emacs now takes a few seconds to load up and then for me just to close it down again afterwards?! (as if I would) Isn’t there another way?, a better way? Could I idea push to an org file from the terminal with a quick flick of the fingers, could bash help me out here?, so many questions…

Well the answer is that yes, bash can help me out.

For me, any new items using org-capture are always put under the headline, hence using file+headline in my capture template. How will this help?, well using the power of bash and the venerable sed command I can search and replace the headline but replace with an extra piece of data, namely a string of my choosing, effectively placing my TODO or note at the top of the org file list!

I thus came up with the following bash scripts:

todo

#!/bin/bash
if [[ ! -z $@ ]]; then sed --in-place 's/* Tasks/* Tasks\n** TODO '"$(echo ${@})"'/g' \ "~/DCIM/content/aa--todo.org" fi

note

#!/bin/bash
if [[ ! -z $@ ]]; then sed --in-place 's/* Notes/* Notes\n** '"$(echo ${@})"'/g' \ "~/DCIM/content/aa--notes.org" fi

Here is my original todo org file:

On the command line I can now enter:

todo generate art slideshows

and in a flash my org file would now be

all nice and ready for the next time I open emacs!, and of course now I can also add notes, or anything else of course.

My aim was for the scripts to be very simple, if you pass in no text / arguments no files will be augmented, generally the idea is just to pass in a single string, maybe multiple lines could be passed using \n but that isn’t the way I wanted to use them.

RIP ripgrep-regexp, long live deadgrep!

James Dyer — Wed, 07 Dec 2022 00:00:00 +0000

Well this is quite a turn up for the books, I seem to have already quickly moved on from emacs ripgrep-regexp! to something better and that is a package called deadgrep

Now why is this? I hear you all ask, your new grepping workflow seemed perfect, a process of file searching that could last the ages. Well as it turns out that age was more of a collection of weeks.

I started to struggle with the compilation-mode output of ripgrep-regexp in that a next-error call would only take me to the requisite file if I entered a directory name. I just wanted to spam F8/next-error my way through all resulted grepped files so I could get a general sense of which files contained my search as I don’t always know what I am looking for. The constant calling up of the directory to input was seriously disrupting my workflow and after some investigation I was struggling to find a way to resolve this.

The main issue seemed to be compilation-mode

compilation-mode seems to depend on compilation-search-path to locate a file automatically in a buffer. This I suspect is generally ok when compilation-mode is tied into a build project as this path is built up automatically, for example building Ada files typically will parse a gpr file to construct search directories. Maybe projectile or project.el could help me resolve this, but as mentioned in previous posts currently a project concept doesn’t yet fit into my workflow.

Well I guess I could create a list of search directories and add it to the compilation-search-path, something like :

(setq my-search-directories (append '("-/bin" "-/test") '("-/content" "~/content/hugo")))

(setq compilation-search-path my-search-directories)

but this isn’t really very flexible, I would have to keep modifying this search directory list as my disk directory hierarchy evolves.

What I need then is an emacs package that doesn’t rely on compilation-mode for its output and will just leverage the ripgrep output to directly locate files.

This is where I found deadgrep and in fact the package text immediately applied half a pot of emollient to the skin of my current rash of irritations :

Perform text searches with the speed of ripgrep and the comfort of Emacs. This is a bespoke mode that does not rely on compilation-mode, but tries to be a perfect fit for ripgrep.

The out of the box behavior is to search for an input string entered in the minibuffer for all occurrences from the current directory. The output is a ripgrep output grouping grep finds together file by file.

Some options appear on the top of the output buffer to provide some quick configuration ripgrep options, such as:

Search term: <search string input> change
Search type: string words regexp
Case: smart sensitive ignore
Directory: <search directory>
Files: all type glob

and all the occurrences of the search string are highlighted.

So the next step (pun intended) is to step through these results and see if they open a window/buffer for each search result.

F8/next-error does the trick!, so a continual F8 opens the relevant grepped file result in a window/buffer and without the need to confirm a directory.

So out of the box deadgrep seems to work perfectly for me, it is lightning fast (well I guess it would be). I can step through the results quickly, it respects my .ignore file and as a bonus allows a quick changing of ripgrep configuration options!, what more could an emacs user want?! (don’t answer that!)

RIP grep, long live ripgrep!

James Dyer — Wed, 30 Nov 2022 00:00:00 +0000

I have come to the realisation that I can be a little more efficient when it comes to searching for text within files, or as it is known in software engineering circles, grepping!

I am often looking for a string within a collection of files and mainly for a Find All References type of functionality. Typically I would want to accept a string (could be regex) and a directory and the search to descend through all sub directories. Of course this could be achieved in many different ways :

Open up an external terminal and grep -iR
dired grepping using find-grep-dired
Built in in grep-find function
Is there a project.el way to recursively grep?
Projectile grepping?

and probably many more that I don’t even know about.

Initially I ran grep from an external terminal, examined the scrolling output and then hopped back into emacs.

Not the greatest workflow.

I guess running a shell or terminal emulator from within emacs may help but I still currently prefer to open an external console to interact with the command line.

At times I have grepped within emacs using the built in grep function which worked well but unfortunately didn’t allow recursive grepping although often I would only want to search in a local directory anyway.

However the calling of this emacs function opened my eyes a little to the possibilities of emacs integrating with a search output, namely the use of next-error to step through the file list.

For me F8 is already bound to next-error for debugging purposes and it seems that this can also be used to step through the results from an emacs grep call, meaning that I can quickly step through each file search result and open a new window buffer with the cursor resting on the grepped line.

A quick look at the out of the box experience for find-grep-dired was subdirectory recursive but just listed the files it found containing the text and not the context so pretty much a no go for me.

The next thing to experiment with is grep-find which seems basically to leverage a find command, typically in the following format:

find . -type f -exec grep -ni <string> /dev/null \{\} +

An F8 takes me to the grepped line as it also seems to running in a grep output mode, so this is pretty good. There are however a couple of downsides:

the command is non native emacs
filtering

Working in a software version control system means that there can be quite a few directories I don’t really want to consider in my search query and generally I am just concerned to grep source code. It would be nice if there was a way to filter out files/directories, which not only would clean up the grep output but also speed up the search.

As we know find can be very annoying and fiddly when it comes to filtering and generally involves a syntactical nightmare of prunes, logic and parentheses, plus you can’t define all these exclusions in a single file like rsync or tar for example.

Ok, so lets carry on, what is next?, it is projects… Now I am going to cheat a little here, I currently don’t use any concept of a project or a collection of related files in emacs, I seem to have no need for this functionality at the moment and to be completely honest I have in the past tried to incorporate a project concept into my workflow but it just doesn’t seen to work for me, maybe a later date.

Which leaves the elephant in the room (and the one that I have so far deliberately not mentioned to irk those of you who are currently rage typing with great vigour in the comment section), the large awesome skulking grep monster! and that of course is ripgrep

I was reluctant at first as it didn’t seem to come pre installed in any of my distros and when I ran it I got a whole slew of lines, why do I need lines of context around the search finds?. I don’t like this one bit, but hang on!, its fast, really fast, maybe I should open up the man page and spend a bit of time with it.

A little time playing with ripgrep I came to the realisation that this tool can be tailored to just show the single line of a grep search result and more than that it can use an exclusion file!, called .ignore

Ok so this tool looks pretty promising, so on to the next step, and of course that is to find an emacs package that can give me an integrated emacs ripgrep experience. So firing up list-packages I settled on a package called (surprisingly), ripgrep which is just a simple front end to “rg* (the installed ripgrep executable) and comes with a command “ripgrep-regexp* and leverages compilation-mode to display the results. As the output is compilation mode it means that the F8 next-error binding will just work out the box.

After a little playing around I can start to tailor the .ignore filter file to trim down the results and make the already lightning fast ripgrep to be extra super duper turbo charged, and the results can be navigated by using F8 which currently sits nicely into my workflow.

Now I have bound ripgrep-regexp to F8 in emacs the workflow is much improved and I can now stay in emacs for longer when I want to run a Find All References type of functionality

Expanding Text using abbrev and skeletons

James Dyer — Wed, 23 Nov 2022 00:00:00 +0000

My next investigation into trying to improve my emacs workflow is expanding entered text for repetitive tasks.

I’m not yet sure how useful this will be for me as I typically copy and paste my way through the creation of text files, especially org files. Maybe org-capture could be a help?

As always I want to try built in options to augment my vanilla emacs setup, so the obvious place to look is abbrev.

This facility can be geared towards fixing common spelling misteaks (ha!, see what I did there!) or expanding acronyms. I don’t really want to be using that aspect however as I read somewhere that you can link abbrevs to skels, my aim is to type a few unique characters which would autofill a common textual structure, for example PROPERTIES in an org file.

What about yasnippet! I all hear you vehemently proclaim!, but of course this is not built in, so no I shall not be considering this option for now.

I am not even familiar with defining a skeleton (skel), so what on earth am I thinking about jumping in like this for potentially a negligible return, well of course the answer is twofold:

it is fun, this is of course emacs we are talking about.
in the long run it will improve my productivity.

The usual way I approach absorbing something new is to first read around all the options and then to start simple. By simple I mean setting up some uncomplicated skeletons and elementary abbrevs to initially test my setup. Then after a while adjusting to this new way of working to gradually start learning the more complex and subtle aspects of the functionality.

Firstly lets try and set up a simple properties skeleton, namely :

(define-skeleton org-hugo-properties-skel
 "org properties skeleton."
 "\n"
 ":PROPERTIES:\n"
 ":EXPORT_FILE_NAME:\n"
 ":EXPORT_HUGO_LASTMOD: " (format-time-string "%Y-%m-%d") "\n"
 ":EXPORT_HUGO_CUSTOM_FRONT_MATTER+: :thumbnail\n"
 ":END:\n")

This is a typical setup for inserting a Hugo article into an org file ready for export, in fact this article is written using this framework.

I can call this by defining keybinding such as :

(global-set-key (kbd "C-c i p") 'org-hugo-properties-skel)

but I suspect my tiny brain is currently full to capacity of emacs keybindings and the ones that are in my head need a little more time to settle in before I commit to any more.

My overall idea is to define a family of common characters that I can insert for expansion as in this case I am talking about inserting a predefined set of text rather than some emacs function, so why commit to another keybinding?

So lets set up abbrev for this task, the first thing to do is to set up an abbrev_defs file for my abbreviation definitions in my emacs init file as thus:

(setq abbrev-file-name (concat home-dir "/content/abbrev_defs"))
(setq-default abbrev-mode t)

In this file I can define an elisp definition, by either linking a sequence of characters to a string or a skel, so I define thus :

(define-abbrev-table 'global-abbrev-table
 '(
 ("hugprop" "" org-hugo-properties-skel)
 ))

There are commands to insert, edit and perform various different operations on this file but really all I want for now is a simple text file that I edit in emacs to add in any new definitions.

So typing hugprop <space> gives me:

:PROPERTIES:
:EXPORT_FILE_NAME:
:EXPORT_HUGO_LASTMOD: <2022-12-11>
:EXPORT_HUGO_CUSTOM_FRONT_MATTER+: :thumbnail
:END:
#+hugo: more

In the define-abbrev-table I can also define a mapping to a simple string, for example:

(define-abbrev-table 'global-abbrev-table
 '(
 ("hugprop" "" org-hugo-properties-skel)
 ("btw" "by the way" nil)
 ))

So now I have figured this out I am ready to go!

After a little while of using this method I was starting to struggle with updating the abbrev_defs and seeing its effects immediately in emacs. When I update to a new abbrev it means that I pretty much want to use it now!

I couldn’t really figure out an easy method of instantly making the newly added abbrev command available (except restarting emacs of course). There will be a way but it wasn’t quickly apparent to me and I suspect it was related to the fact that I am not adding to the abbrev_defs using an emacs function.

Before my investigations consumed too much time however I thought I would try something!.

I am not a great fan of configuration files cluttering up my system and certainly with emacs configuration I really am aiming with my vanilla-ish emacs setup to keep everything in one init file and as concise as possible. So why can’t I move the define-abbrev-table straight into my .emacs file? and just reevaluate an updated abbrev table?

Well the answer is that I can!

Problem solved. So if I feel the need to add more skeletons they can now be defined next to the abbreviation table and I can update immediately with a reevaluation in my emacs init file.

Next on my expanding text journey I think might take a look at dabbrev and hippie-expand

Revisiting Window Cut / Copy Files with DWIM

James Dyer — Wed, 16 Nov 2022 00:00:00 +0000

I previously wrote about wanting the ability in emacs to copy and paste files from one window to another just like a linux GUI file manager and after a little hunting around and experimentation I settled on putting together some elisp:

Cut / Copy Files from Window to Window using Dired Buffers

This worked pretty well for a while although there were a couple of side effects that I hadn’t bargained for!

The first was the bypassing of the trash/wastebasket, of course this can be easily remedied by for example installing trash-put as part of my copy but that is starting to add more lines to the elisp and I didn’t want to complicate things too much.

Also the single rename functionality in dired now didn’t work as I essentially remapped the basic functionality of the R key to set up a flag for a paste operation and I have come to realise that I use the rename often as I would do in a GUI file explorer.

All I want to do is to copy/move files from one emacs window to another, is that too much to ask?, and no, no it isn’t, as there is a much simpler way to achieve this without any of the foibles listed above.

It is:

Dired tries to guess a default target directory

Yay!

So just open a couple of dired windows, mark and operate and the directory dired suggests is the second or destination window dired directory.

Now you may think my previous efforts were wasted but I would disagree with this assumption, I have started to get to grips with elisp, managed to get some elisp working and continued reconsidering my general emacs workflow which as we know will save me time in the long run.

Oh and another thing, the power of writing a blog and trying to articulate what I think I know means that I have read further into the Help for dired-dwim-target. This helps to clarify a few things as sometimes I get a little muddled with renaming files and which window/buffer dired is actually being used, here is a Help snippet:

You can customize it to prefer either the next window with a Dired
buffer, or the most recently used window with a Dired buffer, or to
use any other function. When the value is a function, it will be
called with no arguments and is expected to return a list of
directories which will be used as defaults (i.e. default target and
"future history") (though, ‘dired-dwim-target-defaults’ might modify
it a bit).
The value t prefers the next windows on the same frame.

This is very much something I shall be looking into at a future date, but for now I have something that works and reduces the size of my .emacs file.

Dired Ordering by Size

James Dyer — Wed, 09 Nov 2022 00:00:00 +0000

By default dired orders its files in alphanumeric order and when s is selected it sorts by date according to :

(dired-sort-toggle-or-edit &optional ARG)

But recently I wanted to list files according to their size, which of course is a very common thing to do especially when you are undertaking a nice spring clean up.

The solution is to modify the dired-listing-switches to add in an S argument which can be found by passing in the universal argument to s, hence : C-u s

This presents the user with something like: -al at which point you can just tack S on the end to show -alS

as the ls man page states the following:

 -S sort by file size, largest first

and this is what we get:

a nice ordered listing, it is not something I do often and generally the standard dired sort toggle is all I need, but it is nice to know that this is available.

Tidying up Dired Further

James Dyer — Thu, 03 Nov 2022 00:00:00 +0000

Something is still bugging me with my dired tidy up and I think it is wanting to add the ability to remove dot files.

I am currently using the Dolphin file manager on linux and by default I tend not to show the dot files for a cleaner output, generally the only dot file of course I really care about are the emacs ones and I know where they are!

With some hunting around I copy pasted the following and it works perfectly:

;; hide dotfiles and firefox.tmp
;; Toggle Hidden Files in Emacs dired with C-x M-o
(setq dired-omit-files
 (concat dired-omit-files "\\|^\\..+$\\|firefox.tmp$"))

;; dired omit
(add-hook 'dired-mode-hook (lambda () (dired-omit-mode 1)))

I just now need to muscle memorise the key combination to toggle enable them again, hence:

C-x M-o

(dired-omit-mode &optional ARG)

Toggle omission of uninteresting files in Dired (Dired-Omit mode).

Tidying up Dired

James Dyer — Sun, 23 Oct 2022 00:00:00 +0100

Bit by bit I am getting to grips with dired and using this for more operations on my files.

The next step is to reduce the listing width so that a listing fits better in a smaller window.

Here is the format of my current listing:

By default dired uses -al, which gives a standard long listing. Unfortunately for my work within emacs this is actually now too long, and also not just in emacs but in my terminal too.

After much hunting around the man page including potentially formatting the output and selecting the listing fields manually, I came to the conclusion that it is mainly the group and user I want to remove for the moment, and fortunately there are a couple of arguments that can do this for me:

 -g like -l, but do not list owner
-G, --no-group
in a long listing, don't print group names

and while scrolling through the man page I also thought that making the sizes human readable would also be useful, so I have come up with the following in my .emacs

(setq dired-listing-switches "-lGgha")

to give me the following dired output:

This is much better, but can I now go further?

Well this is emacs, and you betcha!!!!

I know of the command ( which when in dired mode hides the details and shows just the files. Wouldn’t it be great to have this enabled by default?

A quick describe-key gives me the following function:

(dired-hide-details-mode &optional ARG)

But it is not clear how I can set this by default, there is nothing obvious in customize-group for dired, so now to the interwebs…

It looks as though I will need to add to the dired-mode-hook and set the details to be hidden when dired mode is activated as follows:

;; dired hide long listing by default
(defun my-dired-mode-setup ()
 "show less information in dired buffers"
 (dired-hide-details-mode 1))
(add-hook 'dired-mode-hook 'my-dired-mode-setup)

Which now gives me:

and now if I want show the details I just select ( so effectively generally showing details rather than hiding them.

This makes more sense for my workflow in emacs, especially now my buffers and windows are getting a little more numerous and I am still really focussing on trying to use a single emacs frame on a laptop.

Centering the Cursor After a Scroll

James Dyer — Tue, 11 Oct 2022 00:00:00 +0100

Something has been nagging at me for a while now, I seem to spend a lot of time moving the cursor to the next or previous line within a window, spamming C-n and C-p to get where I want to within a file.

Why is this?

Well I am scrolling quite often using C-v and M-v and this has a side effect on the cursor by pushing it to the top or bottom of the window. After I scroll eyeball a file to the desired location I would like my cursor to be vaguely in the center of the window as this is naturally where my eye would have been to identify the file location.

Although I have upgraded the default emacs scrolling to smooth scrolling by using good-scroll I am still having this issue.

One solution is to use M-r

(move-to-window-line-top-bottom &optional ARG)
Position point relative to window.

which moves the cursor first to the middle then the top and then to the bottom of the window. So after a scroll I can just muscle memory M-r? Well I am scrolling quite a lot and the key combination is a little awkward to get to and I want to limit my key presses as much as possible.

Another possible solution is to use recenter-top-bottom but this will just add an extra scroll and the cursor position will be in the wrong place anyway.

There may also be packages out there that will help but I am choosing to ignore this option for the moment due to wanting to keep vanilla emacs as much as possible (yes I know I keep banging on about this!)

Lets see what I can do with some elisp.

Before I discovered the wonder of emacs smooth scrolling using good-scroll I was using some elisp to have greater control over the number of lines the basic scroll--command* would scroll, so I had something like this:

(defun window-some-height () (max 1 / (1- (window-height
 (selected-window))) 4)))

(defun scroll-up-some ()
 (interactive)
 (scroll-up-command (window-some-height))
 )

(defun scroll-down-some ()
 (interactive)
 (scroll-down-command (window-some-height))
 )

with the scroll-some functions bound to the standard scroll bindings.

Now good-scroll is enabled it morphed into the following:

(defun scroll-up-some ()
 (interactive)
 (good-scroll-up)
 )

(defun scroll-down-some ()
 (interactive)
 (good-scroll-down)
 )

as the scroll amount is defined by good-scroll.

My idea here is to modify the scroll functions to add some post scroll cursor centering commands. Maybe I could use (move-to-window-line-top-bottom)!. Well I tried it, but it just didn’t seem to make any difference, I tried some delays, e.t.c. I suspect that the problem here is that good-scroll has a certain method to achieve its smooth scrolling which is incompatible with the function calls I am initially trying.

Well I decided to keep throwing ideas at the scroll functions to see if I could somehow accidentally force a roughly consistent cursor centering after a scroll and see if something sticks (there may be a better term for this!)

Scroll lock didn’t work!, margins didn’t work!

Eventually I managed to find a function call that seemed to make a difference to the cursor position after a scroll but didn’t seem to position the cursor where I thought it should do given the documentation. The function is:

 (move-to-window-Line ARG)
Position point relative to window.
ARG nil means position point at center of window.
Else, ARG specifies vertical position within the window;
zero means top of window, negative means relative to bottom
of window, -1 meaning the last fully visible display line
of the window.
Value is the screen line of the window point moved to, counting
from the top of the window.

Passing in a ’nil parameter was close but the cursor was too skewed to either end (but at least had a consistent effect on the position of the cursor), however it had little or no effect for half height windows after a horizontal split.

However, passing in different arguments to the move-to-window-line function have me differing post scroll cursor locations giving me a licence to that well known tried and tested foolproof method of trial and error!

Of course for a full height window I now had the perfect setup but what about those pesky half height and maybe smaller windows?. There is a valid argument that might say that smaller windows are generally so small that even if the cursor gets pushed to the top or bottom then it won’t take too much effort to reposition the cursor. I would say to an extent that is true but for a half height window I would still want to have a centering cursor option after a scroll.

So again elisp to the rescue!, I modified my scroll functions as thus:

(defun scroll-up-some ()
 (interactive)
 (good-scroll-up)
 (if (< 50 (window-body-height))
 (move-to-window-Line -14)
 (move-to-window-Line -3)
 )
 )
(defun scroll-down-some ()
 (interactive)
 (good-scroll-down)
 (if (<50 (window-body-height))
 (move-to-window-Line 14)
 (move-to-window-Line 8)
 >

The value of 50 was a window line height less than a full window height with a little taken off, but not too much to make it smaller than half height!

Once I have the move-to-window-line values tweaked accordingly for my setup then in theory I have a decent functioning cursor centering solution. Of course there are some foibles, like what happens if I go full-screen with emacs, e.t.c but this seems to work well for me for the moment and I am now moving the cursor around less often within a buffer.

As with all these things and especially emacs I’m sure a better simpler, probably built-in solution will present itself, but that may be for another day…

Do You Remember?

James Dyer — Mon, 10 Oct 2022 00:00:00 +0100

I am currently keeping all my textual notes in a separate org file called appropriately, notes.org. This is pretty much just a random rambling set of text containing bits and bobs that I don’t want to forget.

If I am mobile and want to jot something down I use an android app called Markor, just open up the notes.org as a text file and add something in. Syncthing means that this file is present on my laptop when I open it up in emacs.

In emacs, I can open the file, edit it and save it, but it all seems a little too clunky to me. If I want to just register a thought or idea isn’t there a better way to accomplish this in emacs?, the answer of course as we all know is… YES!

I will add a note right now that am vaguely aware of org-capture but I get a sense that this might be too much in terms of functionality. I really just want a quick method to record some keystrokes in whatever form I see fit.

I will again double down on my main requirement for introducing a new workflow in emacs and that is to use vanilla emacs where I can and that would involve either built-in functionality or maybe a little elisp.

Lets list some packages and search through the built-in emacs packages… The following seems to present itself! :

 remember 2.0 built-in a mode for quickly jotting down things to remember

This seems to be nice and simple and the Help file is quite informative. It is based around the concept of quickly recording something to remember and then organise at a later date. As it says:

the initial “just remember this” impulse should be as close to simply throwing the data at Emacs as possible.

and as we know, emacs is very good at handling data.

Out of the box, running M-x remember brings up a blank Remember window buffer encouraging you to C-c C-c to remember the data, You can enter anything you want and with C-c C-c the window disappears with your input appended to a text file. Perfect!

By default a notes file is stored in .emacs.d/ and I think I might just want to change this to point to my own notes.org. By default the following is a typical entry appended to the bottom of a notes file:

 **Mon Oct 10 15:25:29 2022 (test)
test

This initial form can be tweaked to conform to whatever notes format text file you have, in my case I added the following to my .emacs:

'(remember-annotation-functions nil)
'(remember-data-file "/home/usr/content/notes.org")
'(remember-leader-text "**")
'(remember-notes-initial-major-mode 'org-mode)
'(remember-time-format "")
(global-set-key (kbd "C-c n") 'remember)

Now if a thought occurs and I don’t trust my aging brain to remember, a quick C-c n, text input, C-c C-c flick of the fingers will record that information. The window is transitory and doesn’t disrupt my emacs session and the text org file will be updated and then synced to my phone for a later potential recall.

There are other aspects of remember that I could explore, like what is a diary file?, but I don’t care too much about that, this works perfectly and is another example of the simple out-of-the-box amazingness of emacs!

Dired folder size

James Dyer — Sat, 08 Oct 2022 00:00:00 +0100

My dired replacement of Dolphin / linux terminal continues. The next thing is something useful to me but uncommon and something that dired didn’t seem to be able to do out of the box.

That is to be able to recursively display the size of a folder / files.

Every now and again I like to keep my files and data under control especially as I am using syncthing to backup my core data to my phone.

It is very easy to let a large download or maybe an emacs exported large file sneak through. My tools of choice have generally been the following and in time order:

Terminal using du -h --max-depth 1 <folder>
Gnome Disk Usage Analyser (boabab)
Filelight - now I have moved to KDE

So how do I achieve this?

I could perhaps try something from emacs packages but as you already know my first port of call is to try and preserve vanilla emacs where possible which might mean in this case finding / or writing some elisp.

The www.emacswiki.org comes to the rescue once again! with yet another elisp snippet as thus:

(defun dired-get-size ()
 (interactive)
 (let ((files (dired-get-marked-files)))
 (with-temp-buffer
 (apply 'call-process "/usr/bin/du" nil t nil "-sch" files)
 (message "Size of all marked files: %s"
 (progn
 (re-search-backward "\\(^[0-9.,]+[A-Za-z]+\\).*total$")
 (match-string 1))))))

(define-key dired-mode-map (kbd "?") 'dired-get-size)

I don’t need anything too fancy here, for example a full dired integration like Solid Explorer on android but just showing the total size in the minibuffer is fine and why not leverage the existing operating system commands rather than completely depending on elisp!

Dired going Up Directories

James Dyer — Wed, 28 Sep 2022 00:00:00 +0100

Now dired is becoming more ingrained into my muscle memory, navigating efficiently through the folder structure is becoming more prominent in my mind and it still doesn’t feel natural enough.

I now don’t even think about using C-x d and the Enter key is fine for either opening a file or traversing into a directory. But what about moving up a directory!, also a very common action.

The default defined key is ^ and actually isn’t too bad and almost feels quite natural, almost…

Currently to traverse windows and buffers I am using the M key with comfortable key navigation hand positions as I am using these all the time. I feel like traversing up a directory should have the same feeling, and now I think about it, getting a feel for a hand position and hence an instinctual interaction with the keyboard is almost what emacs is all about (apart from the idea of extension by macros). Anyways, I digress…

What I would like to achieve is a quick command, no more than I am currently using for my window/buffer navigation, so a quick M and another key, one that makes sense and is sensible. So that is why I think I will have to discount the default ^ as it involves the shift key and actually trying to reach the tilda/6 key doesn’t feel that comfortable.

Hence I present the following:

(define-key dired-mode-map (kbd "M-u") 'dired-up-directory)

The hand position is very comfortable, it fits in with the rest of my window navigation keys and u could very well mean up!

But there is something left, something that doesn’t feel right, or natural… and that is switching to dired from a file. Now I have this new defined key to traverse up a directory I have a general feeling that I should be using the same defined key to show dired from when I am visiting a file in a buffer. It is very odd… I can’t explain it, it just feels natural.

If it feels right then I am just going to go ahead and do it, I think the best method is probably to define a macro as thus:

(global-set-key (kbd "M-u") 'file-up-dir)

(fset 'file-up-dir
 (kmacro-lambda-form [?\C-x ?d return ] 0 "%d"))

The macro is just calling dired and then return to action the current directory. That is all I really want to do and for some reason in my own mind I seem to have extrapolated a file to be floating above / or below a directory so it almost makes sense to “go up” a directory to show the directory and hence dired

Cut / Copy between Windows using Dired Buffers

James Dyer — Mon, 26 Sep 2022 00:00:00 +0100

The next step in my emacs journey is to move files around a little more easily, in fact more like a regular file explorer using the concept of file / folder selection copy and paste. That concept seems a little more natural to me than dired file marking, renaming / copying and then entering the path of the destination address.

After a little research the following options present themselves:

Vanilla Dired
- copy target directory to kill ring using 0 w
- mark source files
- copy or rename files and at the directory destination prompt paste in from the kill ring
package Dired+
Own lisp implementation
package Ranger like
DWIM

One main criteria I have for this functionality is that if possible I want to avoid installing any additional packages as I always initially try and look for a way using vanilla emacs.

I have emacs on windows, at work and of course on Manjaro, all slightly different versions and I find relying on third party packages can cause a few problems especially on my work emacs where I have installed potentially incompatible versions of MELPA and emacs. I always like to keep a common as possible initialisation file if possible across all my emacs.

So the choice is between options 1,3 or

Trying number 1 worked well enough but still felt a little clunky and I really wanted to avoid copying and pasting directory names. The number 5 do what I mean concept seems decent enough but seems to mainly rely on opening a window side by side which restricts me as I am a serial window chopper!. Also I have in the back of my mind to explore the whole DWIM concept in the future, especially when related to running commands on selected files.

Therefore the winner is number 3. “my own” lisp implementation. Of course the quotes mean that I am going to borrow and then modify an answer I found on the internet!

The original lisp is as follows

(defvar your-dired-copy-list nil)

(defun your-dired-copy ()
 (interactive)
 (setq your-dired-copy-list (dired-get-marked-files)))

(defun your-dired-paste ()
 (interactive)
 (when your-dired-copy-list
 (shell-command
 (mapconcat
 #'shell-quote-argument
 `("cp" "-r" ,@your-dired-copy-list ,default-directory)
 " "))
 (setq your-dired-copy-list nil)))

and then to define-key add to the dired-mode-map

I feel that my emacs journey is creeping ever onwards and my eyes and heart are opening up to creating my own lisp functions that do things that I want emacs to do. This is a bit of an opportunity to poke a gentle toe into the clear crystal waters of lisp programming.

I have already been exposed to lisp at university although at almost 30 years ago now. It maybe that it will be more of the 25 years of software engineering experience that will help me now!

I think I understand the initial implementation, and I like the concept of leveraging a shell command and hence the functionality of the underlying operating system. But I also wish to move files and directories and not just copy them, so I need some form of flag on the dired marked files action and inform the paste routine which command I wish to perform. So I created / modified my first lisp code as thus:

(defvar my-dired-copy-list nil)

(defun my-dired-copy ()
 (interactive)
 (setq my-move-flag nil)
 (setq my-dired-copy-list (dired-get-marked-files)))

(defun my-dired-move ()
 (interactive)
 (setq my-move-flag t)
 (setq my-dired-copy-list (dired-get-marked-files)))

(defun my-dired-paste ()
 (interactive)
 (when my-dired-copy-list
 (if my-move-flag
 (shell-command
 (mapconcat
 #'shell-quote-argument
 `("mv" "-f" ,@my-dired-copy-list ,default-directory)
 " ")
 )
 (shell-command
 (mapconcat
 #'shell-quote-argument
 `("cp" "-r" ,@my-dired-copy-list ,default-directory)
 " "))
 )
 (setq my-dired-copy-list nil)
 )
 )

and with the following key defines:

(define-key dired-mode-map "C" 'my-dired-copy)
(define-key dired-mode-map "R" 'my-dired-move)
(define-key dired-mode-map "Y" 'my-dired-paste)

So I just set a simple flag depending on if the file is to be moved or not and then IF’d my way to the relevant functionality. Using M to move a file felt more natural but I kept the dired renaming notation of R for consistency and to avoid confusion with changing the marked files mode.

This implementation has the side effect of removing the simple dired single file rename functionality, but as I generally use wdired anyway I don’t think this is too much of a problem.

Trimming Text With Macros

James Dyer — Sun, 25 Sep 2022 00:00:00 +0100

I am having a bet!, it is one of my few vices, and it shall be on the horses. I don’t often have a bet and in fact I generally only ever have a bet on a special occasion, like the grand national or a random parallel bet with my dad.

Today is a parallel bet, yesterday my dad won over £650 and I have decided to leverage his expert equine knowledge to have a little flutter. But wait, I’m not going to do that, I am going to leverage my old javascript horse racing prediction program, the algorithm of which was based on something I wrote on my Amstrad CPC in the mid 80s.

Now what has all this twaddle got to do with emacs I hear you say?, well my javascript program requires a very specific format of horse data and it is in fact a very simple one: number form horsename

My general aim in the past was to pretty much find a website displaying horse data for the chosen race and copy and paste into a web text input field which my javascript would parse and perform its magic.

SportingLife looks like a good one (top of my startpage search). The data though of course is in the wrong order and there is a lot of it for each horse.

My first thought with all these things is how can emacs help me out with this? Well a paste into the scratch buffer gives me something like this:

 1
(5)
Horse silk
Saratoga Goldb27
Age: 4| Weight: 10-2| J: Owen Lewis(5)| T: C Hills| OR: 85| CD
15/8
Has taken his form up a notch
Form: 556811|Timeform
2
(6)
Horse silk
Sword Beachb24
Age: 5| Weight: 9-13| J: George Bass| T: A King| OR: 82
28/1
Dual Windsor scorer in 2021
Form: 71165-0|Timeform

I think the best way to approach this is to open a new window along side the scratch buffer and use this as my formatted output window, I will just create a random blank new file for now called tmp.txt

Then using a macro I can search around extracting each piece of relevant data for each horse and then just copy to the right hand pane.

Once I have a procedure that works for a single horse then I can just end the macro and then C-x e repeat the last keyboard macro and then spam e until all the horses are parsed.

At which point I can copy the text from tmp.txt, paste into the html text input and press Find Winner, lets see if my old algorithm still holds up!

Finding Files With RipGrep

James Dyer — Wed, 21 Sep 2022 00:00:00 +0100

Now I am appreciating the power and simplicity of ripgrep and have it available on all my systems I was hunting around emacs to see the best way to leverage this tool for quick file searching.

Working on a code base that is familiar to me is fine when locating files within emacs as of course I know where to go and when I am not I would typically open up a terminal and use find

As we know, find can be a little picky and fiddly to use and it is not a straightforward process to define the files and folders I am not interested in when returning an efficient search.

Now I have defined an .ignore file to define which files and directories I am not interested in for a regular ripgrep I was wondering if I could also use this somehow to search for files within a project hierarchy and from within emacs.

I have heard good things about projectile and in combination with a completion system it can bring up a searchable file list. This seems like a good solution but unfortunately I have never really found it fits in with my simple workflow, I have always failed to set it up properly and generally I don’t require the ability to switch between projects.

After running list-packages and literally searching for ripgrep, I came across a package called find-file-rg, which leverages the rg --files command to list all files in the directory defined but excluding from the ripgrep defined .ignore file.

Fed into Ivy it means a list of potential files can be displayed and located using its completion system and all I need to define is the following:

(global-set-key [f4] 'find-file-rg)

and hey presto!

Putting to Trash

James Dyer — Thu, 15 Sep 2022 00:00:00 +0100

I was recently reading a post about deleting files from within emacs and pushing them to the local Trash, this seems like a good idea especially now I am using dired more often.

After using describe-function and typing trash there was a single completion, namely move-file-to-trash from this I figured out I should add the following my .emacs:

(setq trash-directory "~/.local/share/Trash/files")
(setq delete-by-moving-to-trash t)

I am running this on OpenSuse so the location of the Trash folder may vary from system to system.

For a more bespoke copying mechanism there is potentially the ability to define system-move-file-to-trash accepting file as an argument, but currently I don’t need anything to be that sophisticated.

Efficient Deletion and Insertion

James Dyer — Sat, 10 Sep 2022 00:00:00 +0100

As my emacs keybindings journey continues to evolve and to delete more efficiently with delete word it has lead to an interesting issue for me.

Typically, especially in my coding life I will typically copy a string to the clipboard, then go in and delete the target area and insert from the clipboard/kill-ring. Now I have moved from deleting with the delete key to the the M-delete-word concept it seems that deleting words automatically puts this to the clipboard/kill-ring, so when I paste in my original copy it pastes back in the last killed words.

Generally I only ever use kill-line when I want a kill to be copied to the kill-ring and I only ever use the word deletion to just delete in preparation for a yank.

A bit of hunting around on the Interwebs lead to the definition of two new functions to be remapped to avoid the kill-ring.

(defun delete-word-back (arg)
 "Delete characters backward until encountering the beginning of a word.
 With argument ARG, do this that many times."
 (interactive "p")
 (delete-region (point) (progn (backward-word arg) (point))))

(defun delete-word-forward (arg)
 "Delete characters forward until encountering the end of a word.
 With argument ARG, do this that many times."
 (interactive "p")
 (delete-region (point) (progn (forward-word arg) (point))))

Images to Blog Posts

James Dyer — Sun, 28 Aug 2022 00:00:00 +0100

I am just playing around with writing some sort of “techy” blog, trying to focus on a couple of my favourite things in the world, namely linux and emacs, so I thought I would do the best productive thing in the world and just start to type.

I have set up this blog in a certain way using a static web site generator called Hugo, but more on that later down the road.

For now I want to just focus on describing what I am tinkering around with at the moment regarding emacs, as yes, I am always tinkering, like a good ‘ol emacs user. Yes I am old, but more on that later down the road…

I am writing this post in org mode and am trying to figure out how to insert an image, of course the first point of call would be org-download, I have tried this package a few times in the past but never quite got off the ground. I understand the concept and would love to be able to drag and drop an image straight into an org file.

This of course can be accomplished using org-download but for publishing my blog it doesn’t quite cut the mustard. Hugo uses org files natively and rather than defining a [[file: type org link it omits the file reference and forward slash starts a reference to the org-hugo-base-dir which would be where my static image files reside.

I had a bit of a hunt around and although I could define which directory the image would be dumped when draggging the file from the file explorer I would probably need to change this for each new post and even then I would need to remove the file: from the link reference.

So I found a simple method:

In emacs dired the directory I want to drag the image
Drag the image, the file is dropped nicely
Use my favourite dired command at the moment 0 w to get the full path of the file name
yank the filename that is on the clipboard into the blog org, “M-d” the start of the path up to the Hugo base directory
Wrap the link in double brackets

Although I said simple, the list of steps looks less simple but as part of the emacs workflow and my emacs muscle memory kicking in I think this provides at present a decent solution.

Here is an image of me using the technique so there!:

It took me about 10 seconds!, not too shabby

Next step, I might look to a good spellchecker, flycheck, aspell, hunspell and all that!

Profiling and Accidental Learning

James Dyer — Sat, 20 Aug 2022 00:00:00 +0100

My sacred emacs is taking 13 seconds to start up!

This is not good, I have read somewhere about a built in profiler, and indeed when I ivy complete for a function profiler I find a plethora of options. profiler-start looks good, and with a little intersearching it all seems simple enough, except it looks as though it probably won’t solve my start up problems but will profile any commands I execute in emacs, so would solve for example an issue I had in the past with deft starting up.

I found a good option in esup, added the following to my .emacs :

(use-package esup
 :ensure t
 ;; To use MELPA Stable use ":pin melpa-stable",
 :pin melpa)

initially it didn’t work and gave me the following:

 error in process sentinel: Wrong type argument: (or eieio-object class), nil, obj

but with a little research I managed to fix it with adding the following to my .emacs :

;; Work around a bug where esup tries to step into the byte-compiled
;; version of `cl-lib', and fails horribly.
(setq esup-depth 0)

and on running esup I get a nice report generated with the top offenders in my .emacs org-download was at the top:

.emacs:36 0.264sec 22%
(use-package org-download)

I like the way it runs up a separate child emacs session to test out the timing on the init file and then generated a report.

But overall the total time was 1.166sec there must be something else going on here. At which point I twigged and remembered that as I have (desktop-save-mode 1) set it means that all my buffers are reloaded on a new emacs startup, once I cleaned all these out, which I do from time to time it only took a couple of second to run up!

I think my lesson from this exercise is the amazing possibilities of learning through investigation and trying to fix issues and emacs is so configurable and so much fun to play around with I find myself learning more and more!

Download Local Emacs Packages

James Dyer — Fri, 15 Jul 2022 00:00:00 +0100

Steps to locally download emacs packages for offline installation.

— TOC

Local ELPA MELPA ORG

cd ~ mkdir -p emacs-pkgs/melpa mkdir -p emacs-pkgs/elpa

# mirror the melpa emacs archive
echo
echo "updating MELPA..."
echo
rsync -avz --delete --progress rsync://melpa.org/packages/ ~/emacs-pkgs/melpa/.

# elpa
echo
echo "updating ELPA..."
echo
rsync -avz --delete --progress elpa.gnu.org::elpa/. ~/emacs-pkgs/elpa

# org (currently no rsync support)
echo
echo "updating ORG..."
echo
cd ~/emacs-pkgs
git clone https://git.savannah.gnu.org/git/emacs/org-mode.git

I then copy the emacs-pkgs directory to the offline target machine and change the default package manager archives to point to these packages.

Modify .emacs in the following manner commenting out the online package communication:

;; (setq package-archives '(("melpa" . "https://melpa.org/packages/")
;; ("org" . "https://orgmode.org/elpa/")
;; ("elpa" . "https://elpa.gnu.org/packages/")))

(setq package-archives '(("melpa". "~/emacs-pkgs/melpa")
 ("org" . "~/emacs-pkgs/elpa")
 ("elpa" . "~/emacs-pkgs/org-mode/lisp")))

Local from Mirror

First, you need to clone this repository.

git clone --depth 1 git@gitlab.com:d12frosted/elpa-mirror.git ~/.elpa-mirror

And then setup package-archives in your init.el file.

(setq package-archives
 `(("melpa" . ,(concat user-home-directory ".elpa-mirror/melpa/"))
 ("org" . ,(concat user-home-directory ".elpa-mirror/org/"))
 ("gnu" . ,(concat user-home-directory ".elpa-mirror/gnu/"))))

https://github.com/d12frosted/elpa-mirror

Extra

ada-mode

ada-mode.el version 4.0 before AdaCore

(add-to-list 'load-path "~/emacs-pkgs/old/ada-mode-4.1")
(require 'ada-mode)

Emacs on Emacs@ Dyerdwelling

Ollama Buddy - Web Search Integration

Ollama Buddy v2.5 - RAG (Retrieval-Augmented Generation) Support

What even is RAG?

Getting started

Indexing your documents

The chunking strategy

Searching and attaching context

A practical example

That’s pretty much it!

Ollama Buddy v2.0 - LLMs can now call Emacs functions!

Automatically Syncing Emacs Tab Bar Styling With Your Theme

Spent a bit of free time polishing ollama-buddy - github Copilot is now onboard!

Ollama buddy now supports cloud models!

<2026-01-28 Wed> 1.1

Auto-Populating Weekly Dates in Org-Mode Tables

Speed Reading in Emacs: Building an RSVP Reader

A single function ripgrep alternative to rgrep

New package dired-video-thumbnail added to MELPA!

Introduction

Features

Whats New

<2025-12-15 Mon> 0.3.0

<2025-12-15 Mon> 0.2.0

Requirements

Installation

Manual

use-package

straight.el

Usage

Basic Usage

With Marked Files

Recursive Mode

Suggested Keybinding

Transient Menu

Submenus

Header Line

Keybindings

Transient Menu

Navigation

Playback

Marking

Deletion

Display

Sorting

Filtering

Help

Customisation

Thumbnail Cache Location

Thumbnail Size

Grid Layout

Wrap Display

Thumbnail Timestamp

Video Player

Video Extensions

Mark Border Appearance

Default Sorting

Recursive Search

ffmpeg Path

Example Configuration

Cache Management

Workflow Examples

Reviewing and Deleting Unwanted Videos

Selecting Videos for Processing

Quick Video Preview

Finding Large Videos

Finding Long Videos

Searching by Name

Troubleshooting

Thumbnails not generating

Placeholder showing instead of thumbnail

Video info not showing in header line

Marks not syncing with dired

Performance with many videos

Related Packages

Setting Up Emacs for C# Development on Windows

Introduction

Prerequisites

The Big Picture

Step 1: Installing Emacs

Using `use-package`

`jira-to-org-parse-buffer`

`jira-to-org-parse-region`

`jira-to-org-parse-and-insert`

`jira-to-org-update-from-jira`

`jira-to-org-default-sprint`

`jira-to-org-default-year`

`jira-to-org-assignee-map`

`jira-to-org-priority-map`

`jira-to-org-status-map`

`jira-to-org-heading-level`

`jira-to-org-parse-string`

`jira-to-org--parse-buffer-to-items`

`jira-to-org--item-to-org-heading`