1. A lightweight website with mobile scaling.
2. Easily rebuild my website and sync it to any web server.
3. Without adding any new software dependencies.

Out of the box Org mode provides many of different exporters for HTML, LaTeX, even plain text. In addition to standard HTML exporting Org provides ox-publish specifically for publishing Org projects as websites.

For my website, I use the following project structure:

~/taingram.org/
├── org/            # content to be exported
│   ├── blog/
│   │   └── example-post.org
│   ├── img/
│   ├── index.org
│   ├── robots.txt
│   └── style.css
├── html/            # temporary export directory
├── publish.el       # site sepecifc publishing config
└── Makefile         # for building the site outside of Emacs

To explain this structure to Org publish we need to set the org-publish-project-alist as follows

(require 'ox-publish)

(setq org-publish-project-alist
        `(("pages"
           :base-directory "~/taingram.org/org/"
           :base-extension "org"
           :recursive t
           :publishing-directory "~/taingram.or/html/"
           :publishing-function org-html-publish-to-html)

          ("static"
           :base-directory "~/taingram.org/org/"
           :base-extension "css\\|txt\\|jpg\\|gif\\|png"
           :recursive t
           :publishing-directory  "~/taingram.org/html/"
           :publishing-function org-publish-attachment)

          ("taingram.org" :components ("pages" "static"))))

From the last line we can see "taingram.org" is broken down into the components "pages" and "static". Each component handles a different part of the website and has its own settings. The "pages" component handles org files as specified by the :base-extension and exports the files to html as per the :publishing-function. The "static" component handles copying over other files like images and style sheets.

For each project component the following options should always be set:

• :base-directory — where the source files are
• :base-extension — what type of file (e.g. org) is being exported
• :publishing-directory — where the exported files are going
• :publishing-function — how the files are exported. Some options are:
  • org-html-publish-to-html — converts org files to HTML
  • org-publish-attachment — copies the files verbatim

Now that we have a basic website exporting we can start experimenting with more advanced settings within Org publish.

Now that we have our website looking more professional we need to publish it to the web server. A fast and simple way is to copy the html/ directory with rsync:

rsync -e ssh -uvr html/ thomas@taingram.org:/var/www/taingram.org/html/

I have always found the Emacs community to be full of extremely knowledgeable and helpful individuals. I would like to thank Thibault Marin on the emacs-orgmode mailing list for his help fixing my custom sitemap function with the suggestion of using an Org mode macro.

Thanks to Lindydancer on Stack Overflow for the initial solution for determining the path of an Emacs Lisp file, and thanks to u/nv-elisp on reddit for their improved solution.

Finally, thank you to all developers of Org mode for producing the best text based organization system in existence. Specifically thanks to David O’Toole who originally contributed Org Publish.

• Publishing Org-mode files to HTML — Worg

Since we are only focusing on native compilation we can just install the default build dependencies as specified by the distros package manager. This will save us time hunting down all necessary dependencies.

You can download the official Emacs 28.1 source code from the below link:

• https://ftpmirror.gnu.org/emacs/emacs-28.1.tar.xz
• https://ftpmirror.gnu.org/emacs/emacs-28.1.tar.gz

You can verify this file by following the instructions in the official release announcement. This will protect you from the file being corrupt or modified.

Extract the archive:

tar -xvf emacs-28.1.tar.xz

Move into the extracted directory and run the following build commands:

cd emacs-28.1
./autogen.sh
./configure --with-native-compilation

Verify the commands complete without errors otherwise you may be missing a dependencies. In addition, verify the below is output otherwise libgccjit is not properly installed.

Does Emacs have native lisp compiler?   yes

If the above has completed correctly, then build Emacs by running make.

make

Once completed you should have a working Emacs 28 binary. You can run it manually and try it out.

./src/emacs

Run M-x version to check it is Emacs 28. Evaluate the following elisp to determine if you have native compilation setup correctly:

(native-comp-available-p)

That's it! Emacs should automatically start natively compiling all your installed packages in the background. You may receive some compiler warnings occasionally until this process has completed.

You can continue running it from the build directory or fully install it using make:

sudo make install

If at any point you'd like to remove it you can run:

sudo make uninstall

emacs --daemon

This can be added to startup files that are sourced at login like your bash profile (~/.profile or ~/.bash_profile) to automatically start the daemon at login.

Now like any other graphical editor you will need a desktop icon in order to open files from your graphical file browser. To do so create a desktop file for emacsclient and place it in ~/.local/share/applications/emacsclient.desktop¹

[Desktop Entry]
Name=Emacs Client
GenericName=Text Editor
Comment=Edit text
MimeType=text/english;text/plain;text/x-makefile;text/x-c++hdr;text/x-c++src;text/x-chdr;text/x-csrc;text/x-java;text/x-moc;text/x-pascal;text/x-tcl;text/x-tex;application/x-shellscript;text/x-c;text/x-c++;
Exec=emacsclient -c %f
Icon=emacs
Type=Application
Terminal=false
Categories=Utility;TextEditor;

Note that some distributions ship with an Emacs client desktop icon by default, like Debian, so this step may be unnecessary unless you want to make use of the script below.

If you frequently start Emacs from the commandline you'll want to start using emacsclient to speed up your startup time. In your ~/.bashrc consider adding one of the following aliases

alias emacs='emacsclient-one-frame.sh'
alias ec='emacsclient -t'                # Opens emacs inside terminal

As an Emacs user on a laptop I like to have the Caps Lock key rebound to Ctrl. In sway this can be done as follows:

input "1:1:AT_Translated_Set_2_keyboard" xkb_options ctrl:nocaps

I use brightnessctl to control this.

# Brightness
bindsym XF86MonBrightnessDown exec "brightnessctl -n set 5%-"
bindsym XF86MonBrightnessUp   exec "brightnessctl set +5%"

Years ago I contributed the -n flag or --min-value. This flag will prevent your brightness from falling to zero and turning off your display.

grim

Very simple command line screenshot tool.

grimshot

A small shell script around grim that provides easy commands to capture a specific windows/regions using your mouse.

# Screenshot
bindsym Print       exec "grimshot save screen"
bindsym Mod1+Print  exec "grimshot save window"
bindsym Shift+Print exec "grimshot save area"
bindsym Mod4+Print  exec "grimshot copy area"

I based these shortcuts off the ones used in GNOME.

By default grim/grimshot will place files in the $XDG_SCREENSHOTS_DIR (default ~/Pictures). This can be overridden by setting $XDG_SCREENSHOTS_DIR if needed.

There is some research that shows blue light in the evening is not good for you. Regardless though it's nice to have the screen a bit warmer when viewing in a dark room.

Gammastep handles this in an extremely easy way. Just set your location (latitude:longitude) and add it to your config. The color temperature can be tweaked if needed.

exec gammastep -l 45.000:-80.000

When there is only one window on the screen the borders are unnecessary. This is normally how "maximized" windows are handled in most floating window desktops. Smart border hiding does exactly that.

hide_edge_borders smart

If you rename your workspaces to something other than numbers they may not be ordered correctly in the sway bar. This can be corrected by adding a "number:" before the name. The numbers can be removed by adding the following to your sway bar settings:

strip_workspace_numbers yes

Example using Japanese Kanji:

# switch to workspace
bindsym $mod+1 workspace 1:一
bindsym $mod+2 workspace 2:二
bindsym $mod+3 workspace 3:三
bindsym $mod+4 workspace 4:四
bindsym $mod+5 workspace 5:五
bindsym $mod+6 workspace 6:六
bindsym $mod+7 workspace 7:七
bindsym $mod+8 workspace 8:八
bindsym $mod+9 workspace 9:九
bindsym $mod+0 workspace 10:十
# move focused container to workspace
bindsym $mod+Shift+1 move container to workspace 1:一
bindsym $mod+Shift+2 move container to workspace 2:二
bindsym $mod+Shift+3 move container to workspace 3:三
bindsym $mod+Shift+4 move container to workspace 4:四
bindsym $mod+Shift+5 move container to workspace 5:五
bindsym $mod+Shift+6 move container to workspace 6:六
bindsym $mod+Shift+7 move container to workspace 7:七
bindsym $mod+Shift+8 move container to workspace 8:八
bindsym $mod+Shift+9 move container to workspace 9:九
bindsym $mod+Shift+0 move container to workspace 10:十

I'm pretty happy with sway and I think I'll stick with it for a while. I love how every rough edge I smooth feels like a step towards creating my perfect computer experience.

Still there are a few edges I still would like to address further. Below are a just a few:

• Launching Applications — I don't like how dmenu by default shows all commands as many I will never need to run.
• Audio Controls — I currently use amixer because that was already included on Debian. I've had some situations where it has behaved inconsistently.
• Customizing Swaybar — I currently use a pretty basic i3status config. It would be interesting to experiment with something different.
• Color Schemes — I currently use the default i3 colors, and it would be nice to come up with something more me.

• Website: https://www.jedsoft.org/jed/index.html
• License: GPLv2+
• Depends on: libc, slang, slsh, and libgpm

JED is a powerful editor in near competition with GNU Emacs. JED is written in a combination of C and the S-Lang scripting language for which JED is the flagship application. JED ships with UTF-8 support and syntax highlighting along with language specific modes for many popular programming languages.

By default JED uses keybindings very similar to Emacs with extra commands available from M-x. There are familiar extras like compile, info, and a shell, there's even a mail reader. JED can be configured and extended with S-Lang making it more flexible and Emacs-like than others on this list.

JED has not had a stable release in over ten years, however, JED is actively developed and the latest development snapshot is only a few months old.

• Website: https://joe:editor.sourceforge.io/
• License: GPLv2
• Depends on: libc, ncurses, terminfo

JOE is a blending of MicroPro's venerable microcomputer word processor WordStar and Richard Stallman's famous LISP based text editor GNU-EMACS […]: most of the basic editing keys are the same as in WordStar as is the overall feel of the editor. JOE also has some of the key bindings and many of the powerful features of EMACS.

The defaults of JOE may be closer to WordStar than Emacs, but that's no problem as JOE provides a number of different configurations. One specifically made to emulate the feel of Emacs is aliased to jmacs. This scheme matches GNU Emacs keybindings with movement, find and replace, transpose, undo, etc. all in their usual places.

In addition, JOE provides extra niceties like syntax highlighting and UTF-8 support. You can run a shell with F3, or compile and grep within JOE using familiar M-x commands.

Read more about JOE on its website and its extensive manual page joe(1).

• Website: https://www.gnu.org/software/zile/
• Repository: https://savannah.gnu.org/projects/zile/
• License: GPLv3
• Depends on: libc, libacl, libgc, ncurses, and terminfo

GNU Zile began as an attempt to make a lightweight Emacs editor (its original acronym was "Zile Is Lossy Emacs"). It has expanded to be a toolkit for implementing small editors with C and Lua. Regardless of this change of scope its stock editor is still one of the better imitations of GNU Emacs available.

[Zile] comes with an example implementation of a lightweight Emacs clone, called Zemacs. Every Emacs user should feel at home with Zemacs. Zemacs is aimed at small footprint systems and quick editing sessions (it starts up and shuts down instantly).

Zemacs looks and feels very similar to running GNU Emacs from the terminal, even sporting the familiar modeline. The similarities go deeper as Zemacs is self-documenting editor with help pages for commands, variables, and keybindings that can be read with the usual Emacs commands (C-h f, C-h v, and C-h k). Zemacs is configured in its own lisp with syntax like a stripped down version of Emacs Lisp. You cannot define new functions, but you can set variables and keybindings.

(global-set-key "key" 'func)

; Column beyond which automatic line-wrapping should happen.
(setq fill-column 80)

Out of the box Zemacs has most of the basic editing commands of GNU Emacs and supports multiple buffers/windows. It lacks richer features like UTF-8, syntax highlighting, or language modes other than fundamental. Zile acknowledges this and recommends using Emacs or JED if you need those powerful features.

For more information check out Zile's website and on your system look at zile(1) and /usr/share/doc/zile/.

• Repository: https://github.com/hboetes/mg
• License: Permissive
• Depends on: libc, libbsd, and terminfo

Mg is a lightweight Emacs-like editor maintained by OpenBSD developers and included in their base operating system. Mg strives to specifically emulate GNU Emacs, so users should feel particularly at home.

This program is intended to be a small, fast, and portable editor for people who can't (or don't want to) run real Emacs for one reason or another. It is compatible with GNU because there shouldn't be any reason to learn more than one Emacs flavor. — Mg's README

Mg is extensively documented, like most OpenBSD tools, within its manual page mg(1). Keybindings with their assigned functions names are all listed and every functions' behavior is documented in detail. Mg supports a wide breadth of Emacs editing commands, you can compile files within mg, and even view directories with dired (a feature absent from other editors on this list). There is only one specific language mode included, c-mode, which adds some indenting help but no syntax highlighting. Mg also supports ctags and cscope to help navigate through large code base.

Configuration for mg is done with a plain text file that looks like elisp but with all the lispy elements stripped out. From this any key can be rebound and settings can be adjusted (example taken from the mg manual):

global-set-key ")" self-insert-command
global-set-key "\^x\^f" find-file
global-set-key "\e[Z" backward-char
set-default-mode fill
set-fill-column 72
auto-execute *.c c-mode

For the most part mg strikes a good balance between minimal and feeling close to GNU Emacs. The most obvious downsides of mg is its lack of UTF-8 support.

• Website: https://sites.google.com/site/e3editor/
• License: GPLv2
• Depends on: (nothing)

e3 is perhaps the most lightweight editor on this list, it has the smallest install size at 121 kilobytes, is written completely in x86 assembly, and has absolutely has no dependencies (not even libc). Yet somehow e3 manages to pack in an editor with 5 different keybinding schemes (e3em for Emacs), an inline calculator, and even UTF-8 support! Each editor has a built in help page and its own manual page containing a list of keybindings for each editor.

That being said the imitation the of Emacs only supports the basic Emacs editing keybindings. E3 does not support any type of configuration file so you have to work with what you're given unless you want to edit some assembly code. The other downside of assembly means you are mostly limited to x86 architecture (e.g. no Raspberry Pi etc.). Still e3's feature set is extremely impressive for its size.

• Repository: https://git.kernel.org/pub/scm/editors/uemacs/uemacs.git/
• License: Shared source with non-commercial redistribution only
• Depends on: libc, curses or termcap

uEmacs is the personal editor of Linus Torvalds, creator of Linux and Git. It is a fork of MicroEmacs 3.9e that Torvalds has added number of improvements to over the years. Most notably the addition of UTF-8 support.

It's unlikely there are many users outside of Torvalds. Its existence is not well advertised and the license restrictions impede uEmacs from be packaged by most Linux distros. Despite that, uEmacs is actively maintained, very small, and supports UTF-8, so for those who need international language support it could be a viable option.

Now that you have seen the many options available for lightweight Emacs lookalikes, its time to ask yourself why are you looking for an Emacs replacement? Is it simply because Emacs starts to slow or just "feels too heavy" for a quick edit. If you don't have a hardware constraint then why limit yourself to an inferior editing experience when good ol' GNU Emacs could work for you.

The following options could help to make Emacs feel snappier for that quick edit:

• Run Emacs without a config: emacs -Q
• Run Emacs with a shorter config: emacs -Q -l ~/.emacs.d/quick.el
• Run Emacs as a background daemon and edit using: emacsclient
• Run Emacs within the terminal: emacs -nw or emacsclient -nw

Using any of these options or a combination can make GNU Emacs feel as fast a lightweight editor. Alias these options to an easy to use command like qe:

alias qe='emacs -Q -nw -l ~/.emacs.d/quick.el'
alias ec='emacsclient -nw'

If you want to use these options from graphical apps like your file manager you can create a .desktop file with these options.

• Getting started with lightweight alternatives to GNU Emacs. OpenSource.com
• UTF-8 Demo. www.w3.org

1. Rename your Org README.org as README and it will be displayed as plain text on the Summary tab.
2. To allow programs to detect the file as Org you can
   • create a symbolic link ln -s README README.org,
   • or for Emacs set a file local variable -*- mode: org-mode -*- on the first line.

For most projects this should be sufficient, Org is extremely readable without any special rendering. For best readability avoid embedding links inside of text paragraphs.

To enable markdown in the export menu you will need to add it to the org-export-backends list from the customize menu or with:

(add-to-list 'org-export-backends 'md)

Now while visiting an Org file we can export it to markdown with C-c C-e m m. This can be done from the commandline with:

emacs README.org --batch --eval '(org-md-export-to-markdown)'

Commit the README.md to your repo and you'll get a nicely rendered markdown file on the Summary tab. This gives us the CSS, syntax highlighting, and headline linking sourcehut provides by default without needing to write markdown.

I recommend using this as a way to write-up a file in Org and then upload it once. Write the readme in Org, export it, commit the markdown file, then throw out the Org file. Trying to maintain two separate README formats seems like a hassle. Even if you automate the process it will likely confuse contributors.

Sourcehut provides functionality for setting your Summary tab to any arbitrary HTML. You can do this easily with the hut command.

hut git update --readme readme.html --repo https://git.sr.ht/~foo/bar

So a simple process for this would be to occasionally export your README to HTML (C-c C-e h h) and then manually upload it with hut. That would work well for a project where the README is updated only occasionally, and keeps the git tree free of extra files.

emacs README.org -Q --batch --eval "(require 'ox-html) (org-html-export-to-html nil nil nil t)"

The flexibility of the sourcehut build system is really neat. I probably would not have used it this way if Org had been supported natively, so that's kind of cool. I could see this being really neat to automatically publish a website or generate a book directly from your git repo. I'm definitely looking forward to experimenting with it for other non-code projects.

• Render README.org as HTML on Sourcehut
• Setting a custom README - git.sr.ht docs

auto-insert-mode includes several default templates you can view in the auto-insert-alist variable. Defaults are included for elisp, C/C++, TeX, Makefile, and HTML. These provide good examples to build your own settings.

On Debian install the following:

sudo apt install arduino python3-pyserial

To access the serial connection necessary for uploading to your device you'll need to add yourself to the dialout group.

sudo adduser $USER dialout

You will need to log out and back in for the change to take full effect. You can check whether you are in the dialout group with:

groups $USER

With the setup complete you should be all set to get started working on a watch face. The Watchy library provides a number of example faces from which you can use as a basis for your own. Open an example watch face File >> Watchy >> WatchFaces. So far I've found 7_SEG to be a good starter for learning, but you should feel free to try out all options.

A basic change you can make to see if things are working is to swap the 7_SEG color scheme by changing line 3 of Watchy_7_SEG.cpp to false.

#define DARKMODE false

Then verify your project with the Check ✓ icon. If it succeeds plug in your Watchy to your computer via USB and click Upload. You'll likely need to confirm your device (something like /dev/ttyUSB0 on Linux), then after a few seconds you should see your watchface invert colors.

I had an issue while building the watchface in Arduino where python could not be found because Debian testing does not currently have a python symlink. I had python3 installed so I added one as follows:

ln -s /bin/python3 ~/bin/python

~/bin= the default location for user scripts in Debian's bash .profile. It will automatically add this directory to the path if it exists so no additional configuration is needed. However, if you had to create this directory you may need to log out and back in for it to take full effect.

For other distros you may need to add ~/bin to your .profile or .bash_profile

# set PATH so it includes user's private bin if it exists
if [ -d "$HOME/bin" ] ; then
    PATH="$HOME/bin:$PATH"
fi

Watchy is a neat little toy and it's crazy you can pack this much stuff in for $50 USD. Although, I would have preferred something more expensive if that meant it was a more polished product. As someone who is not that interested with tinkering with electronics I found the overall package too clunky to actually use and wear.

The final nail in the coffin was when, within my first couple weeks of use, I accidentally snapped one of the plastic buttons (K2-1114SA-A4SW-06). I just don't have enough enthusiasm about the device to go through the hassle of repairing that.

According to the internet the best JavaScript language server is the TypeScript Language Server. This language server can also be used for vanilla JavaScript development as well.

Open a JavaScript file, run M-x eglot, and it should work out of the box. For some additional tweaks below is a minimal Emacs config. Checkout my complete init file to see my actual settings.

;; Emacs LSP Client (built into Emacs 29.1)
(use-package eglot
  :ensure t)

;; Optional, can run M-x eglot to start LSP manually
(use-package js-mode
  :hook ((js-mode . subword-mode)
         (js-mode . electric-pair-mode)
         (js-mode . eglot-ensure)
         (js-mode . completion-preview-mode)))

;; Drop-down completions
(use-package corfu
  :ensure t
  :hook ((prog-mode . corfu-mode)))

;; Add bindings for navigating to next/previous error
(use-package flymake
  :bind (:map prog-mode-map
              ("M-n" . flymake-goto-next-error)
              ("M-p" . flymake-goto-prev-error)))

Corfu is an optional package that will make completions appear as a drop-down menu, similar to a programming integrated development environment IDE. Start typing something then type 'M-TAB' to trigger the completion drop-down. This can be triggered automatically but I find that distracting.

This setup has given me the basic editing environment I wanted with drop-down completions, error checking, and documentation at point. Although there are still some additional enhancements I am hoping to add.

So far things are basically working as expected. I am actually really enjoying learning JavaScript. The post ES6 language spec is pretty fun to work with. I highly recommend javascript.info to get up to speed quickly on modern JavaScript.

Expect to see more posts about web development. I am looking forward to adding some interactivity to my website and working on some other web-based projects. Don't worry though, my website will always work great without JavaScript. It has to look good in eww after all.

• Use npm install -g in ~/.local non-root by James Pic for yourlabs.org

The Language Server Protocol (LSP) is an open standard that strives to solve this redundancy. Developed by Microsoft for Visual Studio Code editor, it works by creating a standard communication method for your editor to talk directly with programming tools. Allowing for features like auto complete, jump to definition, find all references, lookup documentation, and error warnings. This reduces wasted work as an editor needs only to implement an LSP plugin to support all programming languages.

The easiest way to install lsp-mode is through the built in Emacs package manager. First we need to add MELPA, a community maintained Emacs package repository, by adding the following to your init file:

(require 'package)
(add-to-list 'package-archives '("melpa" . "https://melpa.org/packages/"))
(package-initialize)

Then refresh your package list by typing³:

M-x package-refresh-contents

Now we can install with:

M-x package-install RET lsp-mode

I wanted drop down auto-completion so I installed company as well:

M-x package-install RET company

Once you've got your language server open any file on one of your projects and you will be greeted with the following message:

foo.py is not part of any project. Select action:

i==>Import project root /home/name/Projects/FooBar/.
I==>Import project by selecting root directory interactively.
d==>Do not ask for the current project by adding /home/name/Projects/FooBar/. to lsp-session-folders-blacklist.
D==>Do not ask again for current project by selecting ignore path interactively.
n==>Do nothing: ask again when opening other files from the current project.

The options should be pretty self explanatory, use i if the given root is correct, I if the root needs to be adjusted (e.g. you are in a subdirectory). You should only use d and D for project you do not wish to use lsp-mode's project management features.

Now you are good to code. lsp-mode will have automatically started the necessary modes:

• company will provide auto complete suggestions,
• flymake will highlight warnings and errors,
• xref can find the definition of a function or variable, and
• eldoc will show function documentation in the minibuffer.

By default M-. will jump to definition of a highlighted function or variable.

Overall with this basic LSP setup and a few other packages (magit, yasnippets, smartparens, and helm) is enough for me to have a comfortable editing experience with some niceties of an IDE. In the future I'd like to try out Java development using Eclipse's Java language server, as well compare pyls with the Microsoft Python language server.

For someone that would like to take this idea further I would suggest you look into some of the additional lsp-mode packages (lsp-ui, company-lsp, lsp-treemacs, etc.). Also, you could explore making Emacs look more like a modern editor with a nice theme, powerline, NeoTree, and all-the-icons.el.

I'd like to adapt this to work with shell-mode, which should be pretty easy. Then look at excluding some buffer types like *Info*, *scratch*, and *Help* to avoid changing the working directory on accident. I never want to go to /usr/share/info.

I'm planning on participating in the FSF40 Anniversary Hackathon next weekend in support of Emacs Org-mode. I'll be participating with Thibaut who has collaborated with me on org-publish-rss.

In the next week I plan to post a few short articles as I get myself back into the rhythm of writing elisp. Since September, my FOSS contributions have slowed as I have started graduate school for my MBA. Unfortunately my current classes have very little overlap with my Emacs usage. My classmates would rather collaborate using Google Docs than a git server…

To build LaTeX documents we need to install the TeX Live distribution. A full install of the texlive packages is huge and includes thousands of TeX packages. Majority of which I will never use and don't want to install. The problem is to compile Org-mode documents we need several packages that are only included in the extensive texlive-latex-extra and texlive-pictures packages.

Anything tempo cannot identify in the template definition it interprets as raw elisp code. It will insert the final expression output as a string. So we can use this to get variables and run functions. For example I created this template to generate a elisp file header.

  (tempo-define-template "elisp-header"
    '(";;; " (file-name-nondirectory (or buffer-file-name "")) " --- "
      (p "Short Description: ")" -*- lexical-binding: t -*-

;; Copyright (C) 2025 Thomas Ingram

;; Author: Thomas Ingram <thomas@taingram.org>
;; Version: 0.1
;; Package-Requires: ((emacs \"30.1\"))
;; Homepage: https://git.sr.ht/~taingram/
;; Keywords:

;; This file is NOT part of GNU Emacs

;; This file is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 3, or (at your option)
;; any later version.

;; This program is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.

;; For a full copy of the GNU General Public License
;; see <http://www.gnu.org/licenses/>.

;;; Commentary:

;;; Code:

(provide '" (file-name-base (or buffer-file-name "")) ")

;;; " (file-name-with-extension (or buffer-file-name "")) " ends here")
    nil
    "Insert documentation header for a Emacs Lisp file.")

Note this is just an example definition, repetitive file headers are better entered using auto-insert-mode. Another really cool package built into Emacs.

Once I got my head wrapped around the setup I'm really impressed with how easy tempo is to use. I also like that I can create templates and just call them as a function. The extra setup needed with abbrev does not bother me as I rarely want expandable keywords anyways for my workflow.

• Tempo Author David Kågedal's website
• Tempo Mode - EmacsWiki
• tempel.el — Daniel Mendler's modern take on Tempo

On most Linux desktop environments you can create a launcher entry by adding a desktop file in ~/.local/share/applications/. Once added the app icon will appear in your applications list. Here is the calc.desktop file I created:

[Desktop Entry]
Name=Calc (Emacs)
GenericName=Calculator
Comment=Emacs Calculator
Exec=emacs -Q --eval "(full-calc)" -l "~/.config/emacs/early-init.el"
Icon=emacs
Type=Application
Terminal=false
Categories=Utility;

To make sure it launches quickly I'm skipping my full init file with -Q and manually loading my early-init.el to hide the tool-bar etc.. See emacs(1) for all options.

This solution should work automatically in most mainstream Linux/BSD desktop environments. Although you may need to log out and back in to refresh your applications list. If you use a window manager like i3 or sway you can using a custom launcher that supports desktop files, or a script like j4-dmenu-desktop. I use the latter in conjunction with wmenu on sway to launch applications.

# Simple Application Launcher for Sway
bindsym $mod+space exec j4-dmenu-desktop --no-generic --dmenu="wmenu -b -f 'Monospace 16' -i" | xargs swaymsg exec --

If you run emacs as a daemon then you can launch calc directly into an emacsclient frame instead. This has the added benefit of maintaining your calc history and current emacs theme. For further discussion of emacsclient see my earlier blog post.

[Desktop Entry]
Name=Calc (Emacs Client)
GenericName=Calculator
Comment=Emacs Calculator
Exec=emacsclient -c --eval "(full-calc)"
Icon=emacs
Type=Application
Terminal=false
Categories=Utility;

• Calc Manual gnu.org Emacs Advance Desktop Calculator
• j4-dmenu-desktop github.com created by enkore et. al.
• Desktop File Specification freedesktop.org

I found the problem was an issue with tlp, a fantastic tool that helps save power on Linux laptops. Issue was it was cutting power to my audio jack when not in use which caused the loud crackling when it was turned on and off.

Recently I have noticed a constant whining when using headphones. The Arch Wiki provides a solution that seems to work:

amixer -c 0 cset 'numid=10' 1

It is critical to remember reading the news (and social media) is not activism. You personally staying constantly updated will not make any positive impact on its own. The urge to stay plugged in is just draining your mental stamina and feeding the algorithms.

Set limits on when you can access the news and social media. I personally check the news throughout my morning and workday. I check BlueSky when I get off work, then I try to completely get off my phone by 7 PM. I have been trying especially not to check the social media before bed.

As much as possible your free time should be recharging and living life. Be with the people you love. Work on your hobbies, create things! Do things that you enjoy, go hiking, get into 100+ hour long JRPGs. Whatever you need to do. Do not mindlessly doom scroll.

Beyond that make sure you are getting enough sleep. Everything is worse and harder when you are exhausted. This is something I actively have to manage as someone who has problems falling asleep and desperately needs 8+ hours of it. Limit screens before bed. I like to unwind with a book, or at least a very chill game like Dragon Quest.

Trump has shown he does respond to extremely bad press, economic shifts, and approval ratings. If it shown on TV news or negatively impacts support from his base he has pivoted. So there is some value to outrage news, especially if it can generate negative opinion across the right wing.

Talk to people in your direct life about what is going on and why it matters. Especially if they are center or right-leaning. Their news media may be completely ignoring or spinning news stories out of context. That type of small advocacy can be helpful.

Keep in mind our House Representatives are much more easily swayed by bad press and polling. Their elections are coming fast and we need to make them aware that we are paying attention to their actions. Find your House Representative and let them know when you disagree with their action. Further let people in your area know what they are doing.

Find Your Representative - U.S. House of Representatives

I want to keep the scope of this post limited to news and social media consumption, as that is something I personally can speak to. I don't know how to fix politics in this country. I am also privileged that I likely will not be significantly disadvantaged by Trump's policies (unless he starts a recession or war). Regardless of your politics please try to be conscious and empathetic towards the people being negatively affected by our government's actions. Consider further if this is an administration you wish to support.

Please consider contributing to organizations assisting people being harmed domestically and abroad. If you know of good organizations that need support please let me know.

• https://www.aclu.org/
• https://www.rescue.org/