Lately I’ve found myself wanting a better, more fine-grained view of what’s going on in a file under git. For some reason, my default workflow has been to keep jumping in and out of project-vc-dir to check changes. It gets the job done, but honestly it’s a bit of a hassle.

I have been slowly chipping away at my Emacs-DIYer project, which is basically my ongoing experiment in rebuilding popular Emacs packages using only what ships with Emacs itself, no external dependencies, no MELPA, just the built-in pieces bolted together in a literate README.org that tangles to init.el. The latest addition is a DIY version of dired-collapse from the dired-hacks family, which is one of those packages I did not realise I leaned on until I started browsing a deeply-nested Java project and felt the absence immediately.

Flymake has been quietly sitting in my config for years doing exactly what it says on the tin, squiggly lines under things that are wrong, and I mostly left it alone. But recently I noticed I was doing the same little dance over and over: spot a warning, squint at the modeline counter, run `M-x flymake-show-buffer-diagnostics`, scroll through the list to find the thing I was actually looking at, then flip back. Two windows, zero connection between them.

I have been busy improving my annotation package! Simply Annotate, the latest release is 0.9.8 and I have put in a bunch of new features, so it felt like a good time to step back and show what the package actually does at this point, because honestly, quite a lot has changed since I last wrote about it.

Ever found yourself wanting to add a new AI provider to ollama-buddy? (probably not I would guess 🙂), only to realise you'd need to write an entire Elisp module? Or perhaps you're running a local inference server that speaks the OpenAI API, but can't be bothered with the ceremony of creating a dedicated provider file?

There is now an in-buffer replace feature in ollama-buddy, so now an ollama response can work directly on your text, streaming the replacement in real-time, and giving you a simple accept/reject choice!, I have also added an smerge diff inline if desired to show the differences and give the user the ability to accept or reject

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!

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

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!

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.

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.

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 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:

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!

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?

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!

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

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.

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.

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?

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.

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?

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.

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.

—

---

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.

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!

—

---

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!

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

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.

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!

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.

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.

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.

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.

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.

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.

More improvements to ollama-buddy https://github.com/captainflasmr/ollama-buddy

Several improvements in the latest Ollama Buddy updates (versions 0.9.21 through 0.9.35):

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:

• 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!

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.

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.

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.

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.

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.

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:

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.

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!

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

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!

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

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.

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.

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.

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.

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.

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](https://github.com/kaushalmodi/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](https://github.com/captainflasmr/Emacs-enhanced).

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:

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?

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.

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 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!

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.

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.

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. ☹️

I have enhanced selected-window-accent functionality with blending options to blend colourize the selected window (see below):

I am of course using org mode for organizing my tasks, notes and other paraphernalia.

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.

Previously I wrote about the incompatibility of some Emacs themes with the tab-bar and my temporary fix:

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

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.

As an avid ArtRage user for almost 10 years I have in the past delved into the subtle art of editing arscript files:

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.

Using tabs as part of my workflow has enabled a nice encapsulation and collection of files per tab that I can quickly switch to.

I have updated my emacs package selected-window-accent-mode

Regarding my previous post, you can now disregard my little Frankensteinian elisp effort!:

I'm really enjoying ready-player at the moment, so much so I think it might end up replacing emms.

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.

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

I've noticed that my Emacs blog is now almost 2 years old!

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.

More tinkering and enhancements to some AutoHotKey scripts with WOWEE to allow some emacs keybindings throughout the realm of Windows.

I have been continuing to tinker with this project over the last week…

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.

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.

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!

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

Every now and then I find it necessary to use Vim! (mainly for work) - was that clickbait on an Emacs blog?! 😀

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.

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!.

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.

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.

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.

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.

Simply a link to my emacs literate config file 😀

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.

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.

The selected-window-accent-mode is now present on MELPA and is my first Emacs package!

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! 😕

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.

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:

From my previous two posts regarding defining a Selected Window Accent some interesting posts from irreal arose, especially:

Given my previous post regarding accenting the current window:

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:

I can't say that I'm completely happy with the way emacs marks some elements, namely :

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:

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.

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

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!

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.

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.

More improvements to my weight loss table, this time I have added the following:

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.

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)

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 using C-RET or W in dired for a while now to open a file externally via browse-url-of-dired-file.

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.

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.

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.

It is not uncommon for me to want to revert my current buffer.

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

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:

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.

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.

After watching the latest informative video from Protesilaos Stavrou (Prot):

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.

Often I find myself refining my collection of photos and family videos, usually with the following process:

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.

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.

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.

I try and keep a simple colour scheme definition for my web site using some CSS variables:

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:

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

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 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/

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.

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

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 :

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:

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.

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.

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.

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

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.

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:

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 :

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.

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

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 seem to be grepping a lot recently and I think the way I use deadgrep can be improved a little.

Just a quick one.

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:

dired can do most things for me especially now I have my DWIM image conversion scripts working and image-dired configured to my liking.

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.

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.

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

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!

My next investigation into trying to improve my emacs workflow is expanding entered text for repetitive tasks.

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:

By default dired orders its files in alphanumeric order and when s is selected it sorts by date according to :

Something is still bugging me with my dired tidy up and I think it is wanting to add the ability to remove dot files.

Bit by bit I am getting to grips with dired and using this for more operations on my files.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

My sacred emacs is taking 13 seconds to start up!

Steps to locally download emacs packages for offline installation.