notes from /dev/null - casual

Casual now available on NonGNU ELPA

2026-03-03T13:10:00-08:00

If you are an Emacs user who only uses 3rd party packages from ELPA or NonGNU ELPA, I’m happy to announce that Casual is now available on NonGNU ELPA. 🎉

If this is the first time you’ve heard of Casual, it is a project to re-imagine the primary user interface for Emacs using keyboard-driven menus. Casual’s design intent is to make the vast feature set of Emacs easier to discover and use in casual fashion. It does so by providing bespoke hand-crafted menus for different modes provided by Emacs. These menus are opinionated in that the design of what goes into those menus are editorially determined by yours truly. To understand more about what Casual has to offer, please peruse its User Guide.

In terms of implementation, Casual is built using the Transient library made by Jonas Bernoulli. This is the same library that powers the UI for Magit.

Development of Casual has been on-going for nearly two years now. Interested readers can read about Casual’s progress over that time from my blog posts here. Throughout it all I’ve learned a lot about Emacs, its ecosystem of modes, and the powerful features they bring. It has only reinforced my conviction that Casual makes these powerful features more usable beyond what is offered by default in Emacs.

To clarify, if you still get Casual from MELPA (or MELPA Stable), you do not have to change anything. The only difference is that users can now choose to install Casual from either MELPA or NonGNU ELPA. Updates to Casual will be distributed on both equally.

My thanks goes out to the NonGNU ELPA reviewers who have provided guidance in helping get Casual on there. Additional thanks goes out to all the Casual users whose input and support have kept me going at this since 2024.

Announcing Casual Org

2026-02-19T15:00:00-08:00

Most Emacs Org users would concur that Org mode is a magnificent tool for capturing and communicating thought. That said, Org mode’s vast set of features can be daunting to master. A common guidance for new users is to take it slow: incrementally learn a subset of Org’s features as you need them.

A big reason for Org mode’s steep learning curve is that it adopts Emacs’ unfortunate culture of compelling users to memorize keybindings. Learning a distinct keybinding for each Org command (remember I said vast feature set?) is onerous, so a different tack is made: reuse the same keybinding but have it possess different behavior based on context. This context is usually tied to the type of structure the point (aka cursor) is in. For example, if the point is in a source block, the binding C-c C-c would execute it, but if the point is on a checkbox item, then C-c C-c would toggle its checked state. Taking this approach lowers the effort to recall a keybinding at the cost of recalling what its contextual behavior would be. In practice, using such overloaded keybindings is…okay. But I’d argue that we could have a more usable interface, leading to the point of this post:

Announcing support for Org mode in the v2.14.0 update for Casual, now available on MELPA.

Readers of this blog will know that Casual is my project to re-imagine the primary user interface for Emacs using keyboard-driven menus. If this is new to you, I highly recommend reading this introduction to it.

Primary to the design of the Casual Org menus is to be context-sensitive, only showing a subset of Org mode commands that are relevant. This set of context-sensitive commands is opinionated, but seeks to provide utility to users both new and experienced with Org.

Shown below is a demo of Casual Org at work:

Your browser does not support HTML video. Link to video.

While the design of this UI has been months in the making, there is nothing like real-world use and feedback. Constructive input is appreciated, especially if you are relatively new to using Org.

A great deal of thanks goes out to the maintainers of and contributors to Org mode and to the community that uses it. If you are able, please support it. Also, if you find Casual useful, I’d appreciate a coffee as well.

—

Video music: Burna Boy - Last Last (JON REYES FINDAWAY BLEND) | Jon Reyes

Using Casual to work with Emacs Registers, Rectangles, and Windows

2026-02-07T10:00:00-08:00

The features of registers, rectangles, and window management in Emacs are quite powerful yet prior to building Casual, I rarely used them because of the cognitive load of remembering each feature’s command sets, much less their bindings. Using keyboard-driven menus tailored for these three features changed that. Now I only have to recall three key bindings to get easy access to registers, rectangles, and window management. This post demonstrates how you can as well.

Provided you have Casual installed from MELPA, consider making the following global key bindings to your Emacs setup:

(keymap-global-set "C-c r" #'casual-editkit-rectangle-tmenu)
(keymap-global-set "C-c g" #'casual-editkit-registers-tmenu)
(keymap-global-set "C-c w" #'casual-editkit-windows-tmenu)

As always, you can adjust these bindings to your preference.

Each of these menus are detailed further below.

Rectangle Menu (casual-editkit-rectangle-tmenu)

The rectangle feature gives you the ability to mark (select) an arbitrary rectangle region in an Emacs buffer. There are many times where if the text is shaped like a rectangle, making transformations on them is exceptionally convenient. This menu provides you this.

Registers Menu (casual-editkit-registers-tmenu)

Registers provide users a way to temporarily keep track of Emacs run-time state like text clippings, cursor (point) positions, macros, and arrangement of windows.

Registers are a distinguishing feature of Emacs from other applications that support writing. It’s definitely a feature I miss when working outside of Emacs.

Windows Menu (casual-editkit-windows-tmenu)

In Emacs vernacular, a window is a visual organization of how a buffer is displayed. Emacs windows are not the same as what conventional GUIs (e.g. Wayland/X11, Apple macOS, Microsoft Windows) refer to as windows. In Emacs, GUI windows are referred to as frames.

Emacs provides a number of commands to manage windows throughout their entire life-cycle which Casual organizes into the menu shown below:

In practice, I’ve found this menu to be most useful when using a compact/laptop-style keyboard or accessing Emacs via TTY. But if you are using GUI Emacs with a keyboard that has a number-pad, consider making the following number-pad bindings, particularly for selecting focus and swapping windows.

;; Number pad bindings for window management.
;; Requires GUI Emacs.
(keymap-global-set "C-<kp-add>" #'enlarge-window)
(keymap-global-set "C-<kp-subtract>" #'shrink-window)
(keymap-global-set "M-<kp-add>" #'enlarge-window-horizontally)
(keymap-global-set "M-<kp-subtract>" #'shrink-window-horizontally)
(keymap-global-set "C-<kp-enter>" #'other-window)
(keymap-global-set "M-<kp-enter>" #'switch-to-buffer)
(keymap-global-set "C-<return>" #'other-window)

(keymap-global-set "C-<kp-8>" #'windmove-up)
(keymap-global-set "C-<kp-5>" #'windmove-down)
(keymap-global-set "C-<kp-2>" #'windmove-down)
(keymap-global-set "C-<kp-4>" #'windmove-left)
(keymap-global-set "C-<kp-6>" #'windmove-right)

(keymap-global-set "M-<kp-8>" #'windmove-swap-states-up)
(keymap-global-set "M-<kp-5>" #'windmove-swap-states-down)
(keymap-global-set "M-<kp-2>" #'windmove-swap-states-down)
(keymap-global-set "M-<kp-4>" #'windmove-swap-states-left)
(keymap-global-set "M-<kp-6>" #'windmove-swap-states-right)

;; These require the `ace-window' and `transpose-frame' packages.
(keymap-global-set "C-<kp-0>" #'ace-select-window)
(keymap-global-set "C-<kp-divide>" #'transpose-frame)

Note that the bindings for ace-select-window and transpose-frame require that you have the ace-window and transpose-frame packages installed.

Closing Thoughts

Registers, rectangles, and managing windows in Emacs are powerful features that are made easier to use with Casual. If you haven’t explored them, consider trying them out. I think you’ll be pleasantly surprised by what they offer and over time will consider them essential to your Emacs experience.

Announcing Casual EWW

2026-01-22T14:20:00-08:00

I confess to taking a perverse delight in browsing the web from within Emacs. The EWW package that comes with the standard distribution of Emacs makes this possible. On paper, Emacs really has no business trying to support web browsing with its laughably threadbare support for layout and typography, much less its lack of support for multi-threaded operation. In practice though, I’ve found browsing the web from Emacs to be surprisingly useful. To enhance my usage of EWW, I wanted easy discovery of its features via Transient menus. With that motivation, I set out to build Casual EWW, now available on MELPA in the Casual v2.13.0 update.

EWW is a minimal browser in that no CSS nor JavaScript is supported. As such, EWW is best suited for websites that treat HTML as a document specification and not as a sub-system to a web application.

Features of Casual EWW include:

Support for in-page paragraph and link navigation.
Key bindings that match Safari and Chrome on macOS.

In particular M-[ and M-] for historical navigation and M-l for entering a URL to open are supported.
Menus for toggling and configuring the display of a web page (font, colors, images).
Support for document navigation.

This feature distinguishes EWW from other conventional web browsers for navigating websites that support the rel attribute. For example, Texinfo uses the rel attribute in generating HTML output.

Observations and Closing Thoughts

Some observations in using EWW:

The implementation of bookmarks in EWW is… underwhelming.

Note that EWW bookmarks are a different implementation from a regular Emacs bookmark. The EWW bookmark list does not provide a means for ordering a bookmark, much less for sorting and editing them.
The eww-readable command (bound to R) is your friend (when it works).

EWW provides a “reader” mode via the command eww-readable which attempts to display only the main content of a web page. If successful, I’ve found it to vastly improve EWW’s utility.

Setting the variable eww-readable-urls to include documentation from https://developer.mozilla.org will break the command css-lookup-symbol (accessible via Casual CSS) as that command expects the web page to not be in reader mode.

For Emacs users, the utility of EWW is very much a YMMV thing as it can overlap the features of other packages like the Info reader and Elfeed. Regardless of what is preferred, it is assuring to know that web browsing (however limited) is supported within Emacs.

Casual EWW is now available on MELPA in the Casual v2.13.0 update.

Announcing Casual HTML & CSS

2026-01-06T17:40:00-08:00

Although I rarely code up HTML and CSS these days, knowing their basics have brought me compounding rewards time and time again. If you use Emacs, you’re in luck as it provides built-in editing modes for both. These modes can make short work of sculpting your web pages to be presentable to the world at large.

Improving the discoverability of the features in these modes is what the latest v2.12.0 update of Casual is all about. Announcing Casual menus for HTML and CSS, new for 2026, now available on MELPA.

Casual HTML

The main menu for HTML mode is shown below. Tag (</>) operations for inserting, adding an attribute, closing, and deleting are supported.

HTML-specific tags are given their own menu.

Casual CSS

The main menu for CSS mode is shown below. A notable feature is the ability to lookup a CSS symbol from the Mozilla Developer Network (MDN) website using the built-in Emacs browser EWW.

Closing Thoughts

Both HTML and CSS modes support Tree-sitter which offers nice structural navigation features. Although at the time of this writing (Emacs 30.2), using html-ts-mode will break tag deletion (sgml-tag-delete). On the other hand, I use css-ts-mode without issue.

If you haven't used either HTML or CSS modes yet, definitely give them a try using my Casual menus. I think you'll find them to be quite usable.

Announcing Casual CSV

2025-11-24T09:00:00-08:00

Like Make, the CSV file format will outlive us all. That said, editing a CSV file is a precarious task, as it can be easy to violate its separator and escape rules. Thankfully, the Emacs ecosystem has got you covered, with the 3rd party ELPA package csv-mode. This mode provides all kinds of conveniences including:

spreadsheet-like visualizing and editing of fields (field alignment)
separator auto-detection (comma, tab, space, etc.)
support for quoted fields
sorting by fields
killing and yanking fields

To aid in the discovery and usage of these features, I’m happy to announce Casual CSV, a Transient menu for csv-mode, now available in the Casual v2.11.1 update on MELPA.

One notable feature Casual CSV adds is the ability to select a region of rows to copy to the kill-ring as an Org table. This is also usable in Markdown flavors that support tables.

Closing Thoughts and Caveats

YMMV on how well csv-mode works for you as its performance is tied to the size of CSV file you are working with. If you are trying to edit a CSV file that is hundreds of megabytes in size or greater, you might want to think twice before doing this in Emacs with csv-mode.

As a general rule, I try to avoid editing CSV files in the first place, as I prefer to think of them as files for data exchange. My ideal use-case for csv-mode is really for viewing. That said, if you really need to edit a CSV file, it is best to copy it first. Casual CSV reflects this sensibility by offering a command to duplicate a file.

To get the best results out of csv-mode, I highly recommend turning on field alignment and separator auto-detection. In addition, turning off line-wrapping will aid in both visualization and navigation. The following Elisp configuration shows how to do this.

;; disable line wrap
(add-hook 'csv-mode-hook
          (lambda ()
            (visual-line-mode -1)
            (toggle-truncate-lines 1)))

;; auto detect separator
(add-hook 'csv-mode-hook #'csv-guess-set-separator)
;; turn on field alignment
(add-hook 'csv-mode-hook #'csv-align-mode)

Announcing Casual Ediff

2025-10-30T07:00:00-07:00

Truth be told, I find default Ediff to be weird and intimidating compared to other tools that do the same thing, which is to find differences between two files. Like other modes, Ediff is reliant on the user knowing beforehand its commands and respective keybindings, which means it has a steep learning curve. Many of these commands are context specific. While Ediff tries to be helpful by displaying a cheat sheet, I find this feature to be so information dense and context-free (in a bad way) that it usually results in upping my anxiety. I mean, look at this table!

That said, I’m not here to bury Ediff, but to praise it. Ediff is embarrassingly rich in functionality and time-tested. It just needs a better UI, which brings us to today’s post topic: Announcing Casual support for Ediff.

The approach Casual takes is to provide a Transient menu for the Ediff control panel, which is configured to be in the same frame as the windows holding the compared files. This menu organizes relevant commands in sections that map to the files being compared and does its best to be context-sensitive (e.g. determine if the buffer is writable or read-only, know if its a file comparision or a merge, etc.).

The result is an interface that is calmer to my eyes, as shown below.

Casual Ediff builds on the work described in my earlier blog post Using Ediff in 2023, in providing a streamlined way to diff a modified version-controlled file. This way, if you already have the file loaded in a window, you can call casual-ediff-revision to immediately see what changes you’ve made to it and to selectively be able to revert each change.

Casual Ediff also lets you resolve merge conflicts (typically from Magit). Added to Ediff is the ability to merge both conflicting differences in the order of choice by the user (the menu items “Merge A,B to C”, “Merge B,A to C”).

Read more about Casual Ediff at Ediff (Casual User Guide).

Casual Ediff is now available on MELPA as part of the v2.10.0 update for Casual.

It costs money to make, enhance, and maintain Casual as ideologically free software. If you enjoy using Casual, please consider a financial contribution to help support its development and maintenance. Thanks!

Announcing Casual BibTeX

2025-09-24T16:00:00-07:00

Given current events, the importance of having a shared and testable truth is arguably the only thing that matters these days. A time-honored practice to reaching such truth is to write and distribute documentation with good references.

Emacs has long had support for BibTeX, going as far back as 1987. BibTeX is both a bibliography processor for LaTeX documents and more importantly, a database schema for bibliographic data. The significance of the latter allows for using a BibTeX database for contexts outside of LaTeX.

BibTeX organizes bibliographic data into a collection of records (or entries) that are stored in a plain-text file (multiple files are also supported). This plain-text file is identified using a “.bib” suffix and is treated as a database. Any plain-text editor can edit a BibTeX file. This can be seen, especially with 2025 eyes, as a virtue or an anathema. Because the BibTeX database is just a plain-text file, schema enforcement ultimately rests upon the user editing the file.

The Emacs built-in package bibtex tries to help shoulder this schema enforcement by providing commands for both navigating and editing BibTeX data structures (entries and the fields within an entry). In this way, bibtex tries to provide the user a quasi-“form-based” interface to editing a BibTeX file.

Like many other Emacs modes, I find the commands for bibtex-mode to be difficult to both discover and recall. I also find bibtex-mode to not be opinionated enough in trying to provide a form-based experience.

To address this, I’m happy to announce the latest Casual addition: support for BibTeX.

Casual BibTeX organizes bibtex commands into a Transient menu. The bindings remap conventional Emacs navigation bindings for field or entry navigation. Casual BibTeX holds the strong opinion that creation, update, or deletion of either an entry or a field should be done via commands dedicated for those respective operations. Using manual editing of the BibTeX file to achieve the same end is discouraged.

If you are invested in Org, knowing how to work with BibTeX has great benefit as Org has extensive citation support for it.

Casual BibTeX is now available in the v2.9.0 update of Casual on MELPA. Learn more about Casual BibTeX in its documentation.

Announcing Casual Compile, Elisp, and Eshell

2025-07-28T09:00:00-07:00

Another update to Casual has been recently made (v2.8.0) which adds two new interfaces:

Compile for compilation-mode and grep-mode.
Elisp for emacs-lisp-mode.

Belatedly, this post also announces an interface for Eshell which was released in v2.7.0 without much fanfare. We’ll remedy this here.

The v2.8.0 update also does an overhaul of the documentation for Casual, emphasizing the usage of Texinfo (by way of Org) to author it. A benefit for doing so is the ability to export its output to both Info and HTML.

Casual Compile

A common workflow is to use the compile command to run a command line tool, typically make (see also Casual User Guide (make)). If errors occur, then they are listed in a buffer named ✳︎compilation✳︎ which can be navigated upon. The major mode of this buffer is compilation-mode and it offers two ways to navigate this list:

Moving the current selection while simultaneously showing the selected error at its source in another window (aka “following” the selection.)
Moving the current selection only.

By default, the keymap compilation-mode-map binds a number of its commands to use a modifier key (M- or C-) which is too much work for my taste. I prefer a single key binding when possible, so have made the following changes for Casual Compile:

Default Binding	Casual Binding	Command	Note
M-p	k	compilation-previous-error	Use vi convention.
M-n	j	compilation-next-error	Use vi convention.
M-{	[	compilation-previous-file	Single key on `en` keyboard.
M-}	]	compilation-next-file	Single key on `en` keyboard.
C-o	o	compilation-display-error	Single key on `en` keyboard.

The menu for Casual Compile (casual-compile-tmenu) is shown below:

This same menu also applies to Grep results when called from Emacs. This is because Grep output uses a major mode (grep-mode) that is derived from compilation-mode.

Learn more about Casual Compile in the Casual User Guide (Compile).

Casual Elisp

While I’ve been an Emacs user for decades, I’ve only been writing Emacs Lisp (Elisp) for about a year and half now. The menu I’ve created for Elisp is largely a collection of commands that I’ve found useful to have around when developing for it.

This includes functions for evaluation, cross-referencing, byte-compiling, and balanced expression (sexp) navigation.

Learn more about Casual Elisp in the Casual User Guide (Elisp).

Casual Eshell

Eshell has a number of commands to help save you from typing too much. Probably my most favorite command is eshell-insert-buffer-name which will let you choose a buffer via completion. This command is mapped to the binding B in casual-eshell-tmenu.

Learn more about Casual Eshell in the Casual User Guide (Eshell).

Casual User Guide

The User Guide for Casual has been revamped in v2.8.0. Notable features include:

Menu screenshots are now included in the Info file. They can be seen in the Emacs Info reader.
The HTML generated from the same source as the Info file is now published at https://kickingvegas.github.io/casual.
- Supports appearance changes (light/dark mode).
- Responsive for both mobile and desktop screens.

Closing Thoughts

Casual v2.8.0 was a big push, particularly with regards to the documentation. Please provide any feedback on any of the new features in the discussions section for it.

If you enjoy using Casual, please consider making a modest financial contribution to help support its development and maintenance. Thanks!

https://www.buymeacoffee.com/kickingvegas

Announcing Casual Man & Help

2025-06-24T15:00:00-07:00

The penchant for contemporary software today to rely on cloud services becomes a malady whenever said services fail. The recent Google Cloud Platform failure two weeks ago was just one such event whose impact was widespread. By no means is this a novel thing as computer historians would rightfully attest. Complex, changing systems will inevitably fail. Sadly, much of the software in production today is not designed to fail gracefully.

Because the web, an overwhelming amount of computer documentation (reference manuals, user guides, tutorials, etc.) is now read from the Internet. This is great until it’s not. Software that packages documentation “local-first” relaxes having to be on-line to read it. So it is with Emacs and Unix-based systems with Man pages.

Observing the above, I announce two more Transient menus for Casual, one for the Unix Man page reader and the other for the built-in Emacs Help system.

By and large these menus are for navigation features but delving into both Man-mode and help-mode, I’ve come across some TILs:

Setting the variable Man-switches to the value “-a” will display all the man pages for a specified topic.
- This is useful if you have multiple variants of the same utility installed. An example is ls where one variant could be GNU and the other BSD.
In Man-mode, if the point is on another command with a man page, pressing RET (man-follow) will open its man page in another window, regardless if it is a link.
From help-mode, the commands help-goto-info (binding ’i’) and help-goto-lispref-info (binding ’I’, Elisp only) will send you to an Info manual on the current help topic if it is available. (the missing link!)

For Man-mode, I’ve taken the liberty of making an occur-style command using a regexp that looks for a ’-’ or ’+’ command line option. It is bound to ’o’ in the menu casual-man-tmenu.

Both Casual Man & Help are part of the Casual v2.6.0 release on MELPA.

Links

Some earlier posts related to Emacs documentation:

Announcing Casual Timezone

2025-06-02T06:00:00-07:00

Because the Internet, it is a blessing of our time that interacting with people in different time zones is commonplace. In this, the question is often raised: “what time is it there?” This is routinely answered using a clock app or a website.

While Emacs has long had the ability to make time zone calculations, it seemed overdue to have tooling that takes advantage of it.

Announcing Casual Timezone, now available as part of the Casual v2.5.0 update on MELPA.

The following screencast shows Casual Timezone in action, in this case a meeting planner (command: casual-timezone-planner) that compares the hours with your local time zone with that of another.

Casual Timezone also lets you directly ask:

“What time is it over there?” (command: casual-timezone-local-time-to-remote)
“That time over there, what is it here?” (command: casual-timezone-remote-time-to-local)

Note that at current, Casual Timezone only supports Unix-variant systems as it relies on the tz database. It has been tested on macOS 15.5 and Ubuntu Linux 22.04. Sorry Windows users, but I’m open for a PR for Windows support if a workaround for zoneinfo is available.

Closing Thoughts

With experience, I’ve learned to be humble about working with time APIs. While I’ve done much to ensure the results are accurate, I would not be surprised if there are bugs, especially for a first release. Let me know if you find any.

On reflection, putting Casual Timezone together was relatively easy as it was largely an exercise in integrating different Elisp packages:

From Org, the command org-read-date provided the date picker UI.
Built-in completion provided the UI for selecting a time zone.
vtable provided the table interface for casual-timezone-planner.
The table interface was configured as a derived mode to provide mode-specific behavior.
The built-in time functions were used for time zone calculations and formatting.
Transient provided support for menus.

Gonna call this an Elisp code-reuse success story.

References

Announcing Casual Make

2025-03-13T10:00:00-07:00

Back in the 90’s, I did not hold in high regard the Make command with its cryptic syntax, insistence on making a tab space semantically significant, and platform/vendor-specific idiosyncrasies. Surely, I thought then, Make will get replaced by a better tool any day now.

Today it is March 13, 2025. Make is still here and isn't going anywhere. With every fiber of my being I know that Make will outlive all of us. It is now too deeply rooted in our computing infrastructure to go away.

Somewhere in the 2010’s I accepted the above observation and to paraphrase Kubrick, just stopped worrying and learned to love Make.

That said, for all of Make’s ubiquity, there aren't that many tools around to help you edit makefiles.

Emacs supports makefile editing with make-mode which has a mix of useful and half-baked (though thankfully obsoleted in 30.1) commands. It is from this substrate that I'm happy to announce the next Casual user interface: Casual Make.

Of particular note to Casual Make is its attention to authoring and identifying automatic variables whose arcane syntax is un-memorizable. Want to know what $< means? Just select it in the makefile and use the . binding in the Casual Make menu to identify what it does in the mini-buffer.

Casual Make is now available with the latest update of Casual v2.4.0 on MELPA. This is a big update that also includes Info documentation for Casual for the first time.

Closing Thoughts

If your vocation involves programming computers, learn Make. The rewards will pay off handsomely as you will find utility in using Make for tasks both big and small. This is especially so for Emacs users who can take advantage of the compile command which by default invokes Make. The combination of Emacs compilation mode, make mode, command completion & history makes for a compelling IDE for task running.

If you appreciate the Casual project, please support its development and maintenance by buying me a coffee.

References

Announcing Casual Image

2025-01-30T14:45:00-08:00

There’s a certain folly to working on images with Emacs. Certainly there are far better tools designed to do this. However the compelling use case for viewing and editing an image in Emacs is flow, particularly if the editing is relatively simple. More often than not, you already have access to an image file in Emacs. Why not make simple edits to it and stay in Emacs?

To accomplish the above, Emacs provides the built-in package image-mode. I’ll be blunt - I think image-mode has terrible naming of commands and variables, confusing documentation, and arcane bindings. Mouse operations with it are crude. The point must be on the image itself or commands will not work making for a brittle user experience. But if flow is important enough to compel you to using it, I figure you might as well get comfortable.

Announcing Casual Image, a re-imagining of the user interface for image-mode, now available as part of the Casual user interfaces on MELPA. This interface deviates significantly with naming conventions used by image-mode to be more in alignment with conventional image editing tools. It also adds the ability to resize an image file as opposed to resizing a view of it.

Here’s a screenshot:

Casual Image requires that you have ImageMagick installed (either version 6.x or 7.x) to support the resize feature.

Of all the Casual interfaces, this is arguably the most opinionated one due to the name changes. That said, these opinions are hopefully much less surprising. I invite you to give Casual Image a try.

Announcement: Casual talk at EmacsConf 2024

2024-12-02T11:45:00-08:00

Just a heads up that I’ll be presenting at this year’s EmacsConf 2024 with the talk Re-imagining the Emacs User Experience with Casual Suite this Saturday, December 7 at 2:45 pm EST (US/Eastern).

As Emacs users are world-wide, here’s when my talk will happen at different time-zones. If you're interested, please attend! The presentation is prerecorded but I will be there in the chats. EmacsConf is an online conference and is open to all.

America/Los_Angeles	America/New_York	Europe/Berlin	Asia/Seoul
2024-12-07 11:45:00 -0800	2024-12-07 14:45:00 -0500	2024-12-07 20:45:00 +0100	2024-12-08 04:45:00 +0900

See you then!

Announcing Casual Calendar

2024-11-25T09:00:00-08:00

On first impression, it’s a mixed bag using the Emacs built-in calendar & diary, as they both under and over-deliver on features. Users more familiar with GUI-based calendar and journal apps are underwhelmed, as capturing and displaying daily activity with it seem rudimentary at best. Hidden though in calendar is its support for non-Gregorian calendar systems whose inclusion and history are both amazing and idiosyncratic. As common with Emacs modes, calendar & diary rely on user knowledge of its arcane commands and keybindings to make effective use of them. I think such reliance impedes more widespread usage of them, particularly with regards to calendar system conversion and anniversary entry. Given this, I decided to make a Transient-based user interface for calendar & diary.

Announcing Casual Calendar, now available in the Casual v2.2 update distributed on MELPA.

In this interface, emphasis has been given to the following workflows:

Navigation
Conversion of Gregorian dates to non-Gregorian calendar systems
Visualizing holidays
Viewing and creating diary events
Viewing almanac information (lunar phases, sunrise/sunset times)
Configuration of calendar & diary settings

Why Use Calendar & Diary?

Though I have initially described calendar & diary with faint praise, I do strongly recommend getting to know them better. Their utility shows up in many (often surprising) situations where you need to work with dates. Also, their integration into Org Mode alone makes it worth the effort.

My most common use cases for calendar & diary are:

Lightweight visualization of months within Emacs (no need to leave Emacs to see a basic calendar!)
Keeping track of periodic events that do not require notes (e.g. birthdays, anniversaries) in Org Agenda
Org mode timestamp selection

If you share any of these use cases, consider bringing calendar & diary into your Emacs journey.

A notable feature of diary is that it can track periodic events for some non-Gregorian calendars, in particular Bahá’í, Hebrew, Islamic, and Lunar (Chinese). If you find cause to need this feature, you’ll be thankful that you are an Emacs user.

Customizing Calendar & Diary

Both calendar & diary have taken a austere aesthetic when it comes to default settings, where they show the strong influence of the Unix cal command line utility by not visually highlighting holidays or days with diary entries. Users who prefer a richer presentation can follow the following customizations.

To highlight holidays, go to the Settings menu “(,) Settings” and enable “(H) Mark Holidays”.

To highlight diary entries, enable “(E) Mark Diary Entries”.

As sunrise/sunset and lunar phase information is based on location, configuring all the settings in the Location section is advised to enable those features.

Org Agenda users will likely want to include diary integration. Turn this on using the “(d) Include Diary” setting.

An interactive enhancement when navigating (moving) in the calendar window is to add the function call (diary-view-entries 1) to the “(v) Move Hook” setting. This should be called as a lambda expression. In the customize window, it should look like this:

To turn on support for non-Gregorian calendar system diary entries, the two settings “(L) List” and “(M) Mark” must be configured in the section Non-Gregorian Hooks. Note that if you are working with Emacs 29.4 or earlier, you will only see checkboxes for the Bahá’í, Hebrew, and Islamic calendar systems. To get Lunar (Chinese) support requires manual entry of the values diary-chinese-list-entries and diary-chinese-mark-entries for “(L) List” and “(M) Mark” respectfully. Thankfully, the upcoming official Emacs 30 release will fix this.

Closing Thoughts

Suffice to say, it is fundamentally human to mark the passage of time. Emacs, by including calendar & diary acknowledges this obvious fact. Incorporating calendar & diary into my Emacs workflows has yielded considerable benefits, sometimes surprisingly so. My motivation for building Casual Calendar was to make calendar & diary easier to use. Perhaps you’ll share the same sentiment.

Some Self-Promotion

If you enjoy using any of the Casual packages I’ve published over the past year (Agenda, Bookmarks, Calc, Calendar, Dired, EditKit, IBuffer, Info, I-Search, Re-Builder), please consider “starring” the project on GitHub if you already haven’t done so. Financial support is also welcome as it helps the development and maintenance of Casual. Please consider buying me a coffee to provide it. Thank you.