tusharhero's pages about Emacs

PALE, Canvas, and Stuff demos

Tue, 17 Feb 2026 00:00:00 +0530

~1462 words. ~7 minutes.

The various demos relating this were seriously getting out of hand. I hope to properly demo them, and provide some background.

I will try to keep improving and updating this page regularly.

In-tree PALE days (tiling)

PALE stands for “Picture and Animation Library for Emacs”, it grew out of struggles with rendering in Emacs Reader. Wherein quickly changing the page image would lead to memory leaks– the reason for the delay in implementing text-features (like selection and friends). We eventually decided that ‘tiling’ that is, dividing the page into smaller images would be a good solution, ( though we ended up finding an easier to implement solution later).

PALE rendering a bouncing square.

PALE rendering gradient animations

Pale rendering 20 bouncing squares inside an Emacs buffer.

Emacs playing the video of RMS singing the hacker song using PALE.

Separate PALE repository (tiling)

Divya was so excited by PALE's video playing that he just extracted PALE into a separate repository.

PALE rendering smooth in 30 FPS without major flickering.

bad apple video playing in an emacs buffer.

Canvas API

Minad (Daniel Mandler) saw Divya's posts, and basically said,

wow, that is so much work, actually I had an idea to add a canvas into Emacs long ago, let me just do that: here is a patch.

funny animation with a lot of colored rectangles and emacs logos appearing everywhere, with a red falling star-like streak appearing in the background, chaos.

funny animation with a lot of colored rectangles and emacs logos appearing everywhere, with a red falling star-like streak appearing in the background, chaos. With a FPS counter at around 400 at the bottom (minibuffer).

Minad ported Doom to Emacs.

doom running inside an emacs buffer.

Simple cube rendered by OpenGL inside Emacs

Divya ported SuperTuxKart to Emacs.

SuperTuxKart inside Emacs at 60FPS

PALE

Divya ported PALE to Canvas (no more tiling hacks).

A 1080p video playing inside Emacs

Emacs killing a video being played inside a canvas and yanking it in different buffers.

ob-canvas

Daniel added shaders to org-babel.

Emacs displaying an Org mode buffer with an Org babel block generating an animated graphic.

Emacs with Org Babel rendering via a GL shader

Hypnomacs

ANN: Modus Gotham is here

Sun, 09 Nov 2025 00:00:00 +0530

~94 words. ~0 minutes.

tags: emacs

Inspired by Magnus's blog post on creating a theme based on Modus, I decided to try my hand at implementing the gotham-theme using modus-themes.

This is my first time creating a theme, so don't expect it to be perfect yet.

https://codeberg.org/tusharhero/modus-gotham

You can install it via package-vc for now.

It took me approximately 2.5 hours to get this far.

GNU Emacs needs a virtual keyboard

Mon, 27 Oct 2025 00:00:00 +0530

~929 words. ~4 minutes.

tags: emacs

I mean this more generally as in everywhere GNU Emacs is available, but especially the recent Android port.

If you are like most people, you have probably had to edit text on a mobile phone. And then you must be aware of how the virtual keyboard is not just used for entering characters into the text area, but it in fact assists the user while editing the text, through auto completions, cursor movement through the keyboard, and so forth and so on.

Now I would guess most of you haven't tried GNU Emacs on Android for any extended amount of time, but from my time seriously using it on Android (for the past 3 months, mostly for Org-Agenda and friends). I can say that it is actually pretty useful(and able), and IMO is the best org client on Android. The trick to using it on Android is not disabling the GUI elements (like the menu-bar, tool-bar, and the likes), these elements are really useful and you can do many complex editing operations using them, you can even go further, by creating your own menu-bar items, tool-bar icons, etc.

Though, one could say this is generally true for Emacs, too many people ask beginners to disable the helpful menu-bar and tool-bar.

There is also an especially useful GUI element called the modifier-bar-mode,

Toggle display of the modifier bar.

When enabled, a small tool bar will be displayed next to the tool
bar containing items bound to
‘tool-bar-event-apply-control-modifier’ and its related commands,
which see.

This is a global minor mode.  If called interactively, toggle the
‘Modifier-Bar mode’ mode.  If the prefix argument is positive, enable
the mode, and if it is zero or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is ‘toggle’.  Enable the
mode if ARG is nil, omitted, or is a positive number.  Disable the mode
if ARG is a negative number.

To check whether the minor mode is enabled in the current buffer,
evaluate ‘(default-value 'modifier-bar-mode)’.

The mode’s hook is called both when the mode is enabled and when it is
disabled.

(fn &optional ARG)

What it does is expose the Ctrl, Shift, Meta, Alt (Yes, they are different.), Super, and Hyper keys as buttons on this modifier-bar. This is very similar to what Termux does. And also very useful (though I still use the unexpected keyboard in conjunction with this).

The need for a full fledged keyboard is further demonstrated by this development. The Emacs virtual keyboard would be a natural extension of the idea.

Emacs' virtual keyboard could be made very dynamic, changing its keys/buttons according to the mode we are in. For example, when we are in Org-Mode, we could have specialized keys for it!

This is not something that has not been tried before, take a look at calc-keypad,

Invoke the Calculator in "visual keypad" mode.
This is most useful in the X window system.
In this mode, click on the Calc "buttons" using the left mouse button.
Or, position the cursor manually and do M-x calc-keypad-press.

(fn &optional INTERACTIVE)

This is how it looks currently,

----+----+--Calc---+----+----1
FLR |CEIL|RND |TRNC|CLN2|FLT |
----+----+----+----+----+----|
 LN |EXP |    |ABS |IDIV|MOD |
----+----+----+----+----+----|
SIN |COS |TAN |SQRT|y^x |1/x |
----+----+----+----+----+----|
  ENTER  |+/- |EEX |UNDO| <- |
-----+---+-+--+--+-+---++----|
 INV |  7  |  8  |  9  |  /  |
-----+-----+-----+-----+-----|
 HYP |  4  |  5  |  6  |  *  |
-----+-----+-----+-----+-----|
EXEC |  1  |  2  |  3  |  -  |
-----+-----+-----+-----+-----|
 OFF |  0  |  .  | PI  |  +  |
-----+-----+-----+-----+-----+

Here, they just look like regular text, but maybe using Emacs' buttons would look better, the task is making it standardized and easy to add, like how Org-Mode does its own ad hoc transient-like menus, but now with transient, it is easier to make such menus and all the menus look similar, so the same muscle memory is utilized in of all of these menus coming from different packages.

When Emacs has its own toolkit (some day I hope), the virtual keyboard would get even more powerful!

What if we also made it possible for Emacs to be used as the keyboard on Android, so that it is possible to edit texts using Emacs on any text area anywhere on the operating system? This would be analogous to emacs-everywhere or tinee on GNU/Linux systems, though would probably be better integrated with the rest of the operating system.

All these are just thoughts I have had for a while, that I finally decided to put on buffer. I don't have plans on working on this in the near future, but if someone else is interested I would love to see it being realized.

SVG? Yes!

Mon, 20 Oct 2025 00:00:00 +0530

~165 words. ~0 minutes.

tags: emacs meta

This post by nwalsh shows how to use SVG in Org generated HTML pages. I would like to showcase yet another way you can use SVGs in Org generated HTML pages, and that is through Org Babel.

( let ((svg (svg-create 400 400  :stroke-width 10)))
  (svg-gradient svg  "gradient1" 'linear '((0 .  "red") (100 .  "blue")))
  (svg-circle svg 200 200 100  :gradient  "gradient1"
               :stroke-color  "green")
  ( with-temp-buffer
    (svg-print svg)
    (buffer-substring-no-properties (point-min) (point-max))))

These are the header arguments I used,

#+begin_src emacs-lisp :exports both :results html

I have been wanting to do some dynamically generated SVG images on my website, but I haven't gotten many ideas yet.

I currently only use this technique (without the SVG) for generating those colorful random dots on the homepage.

Obscure Emacs packages

Mon, 08 Sep 2025 00:00:00 +0530

~590 words. ~2 minutes.

tags: emacs

This is my second submission to the Emacs Carnival (my first one was emacs elevator pitch). The theme this time around is about obscure emacs packages. I figure I will just talk about the obscure packages I use.

Org Custom Cookies

homepage

This package by gsingh93 allows you to define your own custom cookies for org-mode. This was the first package I ever contributed to :).

I no longer use it though. I think I had used it to add a counter cookie for the number of subheadings of an org heading.

Yeetube

homepage

This package by Thanos Apollo allows you to search for YouTube videos and play them through mpv (which uses yt-dlp under the hood). As we all know, YouTube is a demonic proprietary website but unfortunately a lot of videos are only available on YouTube. So as much as I would like to only rely on Peertube and friends, I can't.

Yeetube directly parses the search results from the search page HTML, this is what differentiates it from tools like ytfzf which rely on the invidious api to get the search results. The problem with invidious is that because YouTube keeps blocking them, there is no guarantee that the instance you use now will work reliably tomorrow. AFAIK, ytfzf also used to directly parse the YouTube search result pages, I am not sure why they stopped.

And after parsing the search results, it displays them in a neat table with THUMBNAILS! And it also allows you to control mpv from within Emacs.

tinee: tinee is not emacs everywhere

homepage

This time the author is me! The package name is a homage to the venerable emacs-everywhere package. Of which tinee is just a simple substitute on Wayland.

For those who don't know what emacs-everywhere or tinee are supposed to do, they allow you to use Emacs to write everywhere on your computer. This is done by binding a key to tinee/emacs-everywhere in your desktop environment, which then opens up a small emacs frame for you to type what you want, after you are done, it automatically sends the content into the proper place.

Emacs Reader

homepage

This is a very ambitious project by Divya Ranjan. It aims to completely replace PDF-tools and DocView.

It uses MuPDF in the backend via a dynamic module.

Currently, it is still in very initial stages but we already have:

RIDICULOUSLY better performance and smoothness and responsiveness in comparison to both PDF tools and DocView.
All formats supported by MuPDF (not just PDFs, EPUBs, and stuff too).
multithreaded rendering of the documents
dark-mode
imenu and outline
bookmarks and saveplace support

Currently, we are trying to implement text related features.

Emacs Elevator Pitch

Wed, 27 Aug 2025 00:00:00 +0530

~45 words. ~0 minutes.

tags: emacs

"Emacs gud."

"Okay."

Hunk editing with Magit

Mon, 11 Aug 2025 00:00:00 +0530

~591 words. ~2 minutes.

tags: git emacs tutorial

This was asked in a reddit post,

I want a separate commit for edits A, B, and C

Line 1 Line 2 editA Line 3 editB Line 4 editC Line 5

From the command line I do.

git add -p

git commit

That's hunk editing. Instead of untying an impossible knot you whack it apart with a machete (ie hunk edit).

Now with magit. I can select things in the status buffer with regions. But this falls apart when changes are entangled and not contiguous.

How do you do this in magit? Even vc doesn't support hunk editing. How can the ultimate editor in the pantheon of editors have overlooked hunk editing? Yeah I know you can set $editor to Emacs and edit hunks but I would like to master a 100% emacs workflow without switching to the terminal.

It is a bit confusing but their problem is that they want to only commit the Line 2 diff part. But they don't actually tell you how their diff looks like or what the original file was, if we are to make a reasonable guess, I would say their initial file looked like this.

line 1
line 2
line 3
line 4
line 5

And then they edited it to be like so,

line 1
line 2 editA
line 3 editB
line 4 editC
line 5

Now the diff looks something like this,

 diff --git a/file b/file
index a751413..7ecd66d 100644
---   a/file 
+++   b/file 
 @@ -1,5 +1,5 @@
 line 1
 - line 2
 - line 3
 - line 4
 + line 2 editA
 + line 3 editB
 + line 4 editC
 line 5
\ No newline at end of file

The first thing that comes to mind is actually quite naive; to simply mark the -line 2 region and then +line 2 editA region, one by one, but that approach actually leads to a difference like this.

 diff --git a/file b/file
index a751413..7beac75 100644
---   a/file 
+++   b/file 
 @@ -1,5 +1,5 @@
  line 1
 - line 2
  line 3
 line 4
 + line 2 editA
  line 5
\ No newline at end of file

The commit would ultimately look like this,

line 1
line 3
line 4
line 2 editA
line 5

The author of the Reddit post refers to it as, very confusingly, a 'corrupted commit', but it's not actually a 'corruption', rather it's simply not what was expected.

Thankfully, all you need to do to fix this is to simply type e on the staging area to open up Ediff. In the Ediff control buffer, type B to disable read-only mode for 'index', (which is essentially the thing you staged). Then happily edit the staging area to how you want it to be.

After doing that, I have this diff in the staging area,

 diff --git a/file b/file
index a751413..4207b6e 100644
---   a/file 
+++   b/file 
 @@ -1,5 +1,5 @@
  line 1
 - line 2
 + line 2   editA 
  line 3
 line 4
 line 5
\ No newline at end of file

Which is what we need!

This is a very unusual operation that I frankly never needed to do before reading that post (Hence the confusion in the comment section). But yes, Magit can help you with this too.

Creating a blog

Fri, 25 Apr 2025 00:00:00 +0530

~11787 words. ~58 minutes.

tags: meta programming emacs

Introduction

I have been blogging by manually exporting my org-mode files into HTML with a custom CSS file and then SCP-ing the generated HTML file into my SDF personal page. While this works fine, The page doesn't have any SSL certificate, which just makes my website look bad. So I have recently decided to switch my blog over to Codeberg and utilize their pages facility.

The implementation

After some research, I've found out that Codeberg pages doesn't have any support for static site generators like Github pages does, But I am not deterred by this. I have devised a plan to use Codeberg effectively.

Firstly, I have created a private repository with all my articles on it (in org-mode format of course), I also have the scripts necessary to perform this on there, which are

An Emacs lisp script, and
A shell script

Emacs Lisp script

The Emacs lisp script actually exports the Emacs Org-files into a HTML directory.

I will go over each (interesting) part one by one.

Cleaning public

(message  "Cleaning public/")
(shell-command  "rm public/*")
(message  "Done!")

This block just removes the old public directory, this is done to ensure that no files that were "removed" or "drafted" stay public.

Customizing HTML output

 ;;  Customize the HTML output
( setq org-html-postamble t                     ;  use org-html-export-format
      org-html-head-include-scripts nil        ;  Use our own scripts
      org-html-head-include-default-style nil  ;  Use our own styles
      org-confirm-babel-evaluate nil           ;  Don't ask permission for evaluating source blocks
      org-html-html5-fancy t
      org-html-htmlize-output-type 'css
      user-full-name  "tusharhero"
      user-mail-address  "tusharhero@sdf.org"
      org-html-with-latex 'verbatim
      )

I would say the most interesting part is the line where I disable prompt for asking permission before evaluating the babel source blocks, that is because, I am using emacs-lisp org-babel source blocks to generate text here and there, particularly I am using it right now to copy code from actual files during build time. I won't go over how exactly that is done, because I am still figuring it out.

Add setup.org to every page

 ;;  add setup.org to every page
(add-hook 'org-export-before-processing-hook
          #'( lambda (backend)
              (insert  "#+INCLUDE: \"../setup.org\"\n")))
 ;;  done

I currently use this to add a tag list to each page.

 #+HTML_HEAD: 
 #+HTML_HEAD: 
 #+HTML_HEAD: 
 #+HTML_HEAD: 

 #+name: word-count
 #+begin_src elisp :results raw :exports results
   (  let*  ((word-count (  save-excursion  (search-forward   "#+title:"  nil nil 2)
                                   (forward-line 3)
                                   (count-words (point) (point-max))))
         (reading-speed 200)
         (reading-time (/ word-count reading-speed)))
    (format   "/~%s words. ~%d minutes./"  word-count reading-time))
 #+end_src

 #+name: tagging
 #+begin_src elisp :results html :exports results
   (  defun    p/get-tags  ()
      "Get the tags in buffer." 
    (  save-excursion  
      (goto-char (point-min))
      (search-forward   "#+tags:"  nil nil 2)
      (string-split
       (string-trim (thing-at-point 'line t)   ".*tags:\s*" )
         ":" )))

  (  let  ((tags (delete   "special"  (p/get-tags))))
    (  if  (not (= (length tags) 0))
        (format   "tags: %s
" 
                (string-join (mapcar (  lambda  (tag) (format   "%s"  tag tag)) tags)   " " ))
        "" ))
 #+end_src
 #+OPTIONS: toc:nil
 #+TOC: headlines 5

I also have a listing of all pages according to their tags here.

Defining publishing project

 ;;  Define the publishing project

Now, all of this is pretty standard, I think you can just guess what each part does, but the most interesting part is :html-home/up-format option, it allows to put the navigation bar in the general HTML, even though I could have done by defining a completely new element, but I decided that reusing old functionality is probably best here.

CSS minifier at home

As you can see in Styling, my CSS is a bit too large (by my standards). So I decided to minify it a bit… and this is what I wrote

(message  "Starting the minification of CSS...")
( save-excursion
  (find-file  "public/style.css")

   ;;  Remove comments
  (replace-regexp-buffer
   ( rx  "/*"
       (zero-or-more ( or (not (any  "*")) (seq  "*" (not (any  "/")))))
       (one-or-more  "*")  "/")
    "")

   ;;  Remove new lines
  (replace-regexp-buffer ( rx  "\n")  "")

   ;;  Replace multple spaces
  (replace-regexp-buffer  ( rx (>= 2  "\s"))  " ")

   ;;  Remove some useless spaces
  ( dolist (symbol (list ?{ ?} ?\; ?, ?> ?~ ?-))
    (replace-regexp-buffer (format  "%s " symbol) (format  "%s" symbol))
    (replace-regexp-buffer (format  " %s" symbol) (format  "%s" symbol)))
  (replace-regexp-buffer  ( rx  ": ")  ":")

  (save-buffer))

Here is the definition of replace-regexp-buffer.

( defun  replace-regexp-buffer (regexp to-string)

It is a very basic minifer it doesn't really do anything complicated but I have managed to save up to 2.4KB using it, which is pretty good.

Full script

Here is the script, ( It's licensed under the GPLv3 Copyright @ tusharhero 2024, although most of it has been taken from this tutorial.)

 ;;;  build-script.el --- Build Script for website  -*- lexical-binding: t; after-save-hook: (lambda nil (compile "./build.sh")); -*-
 ;;;  Commentary:
 ;;  Licensed under GPLv3 Copyright @ tusharhero 2024
 ;;;  Code:

(message  "Cleaning public/")
(shell-command  "rm public/*")
(message  "Done!")

(message  "Getting dependencies, may take some time...")

 ;;  Add melpa
( require ' package)
( setq package-user-dir (expand-file-name  "./.packages"))

 ;;  Initialize the package system
(package-initialize)
( unless package-archive-contents
  (package-refresh-contents))

 ;;  Install dependencies
( dolist (package '(htmlize
                   webfeeder
                   dash))
  ( unless (package-installed-p package)
    (package-install package)))

 ;;  From https://github.com/alphapapa/unpackaged.el#export-to-html-with-useful-anchors

( require ' dash)

( define-minor-mode  unpackaged/org-export-html-with-useful-ids-mode
   "Attempt to export Org as HTML with useful link IDs.
Instead of random IDs like \"#orga1b2c3\", use heading titles,
made unique when necessary."
   :global t
  ( if unpackaged/org-export-html-with-useful-ids-mode
      (advice-add #'org-export-get-reference  :override #'unpackaged/org-export-get-reference)
    (advice-remove #'org-export-get-reference #'unpackaged/org-export-get-reference)))

( defun  unpackaged/org-export-get-reference (datum info)
   "Like `  org-export-get-reference ', except uses heading titles instead of random numbers."
  ( let ((cache (plist-get info  :internal-references)))
    ( or (car (rassq datum cache))
        ( let* ((crossrefs (plist-get info  :crossrefs))
               (cells (org-export-search-cells datum))
                ;;  Preserve any pre-existing association between
                ;;  a search cell and a reference, i.e., when some
                ;;  previously published document referenced a location
                ;;  within current file (see
                ;;  `  org-publish-resolve-external-link ').
                ;; 
                ;;  However, there is no guarantee that search cells are
                ;;  unique, e.g., there might be duplicate custom ID or
                ;;  two headings with the same title in the file.
                ;; 
                ;;  As a consequence, before re-using any reference to
                ;;  an element or object, we check that it doesn't refer
                ;;  to a previous element or object.
               (new ( or (cl-some
                         ( lambda (cell)
                           ( let ((stored (cdr (assoc cell crossrefs))))
                             ( when stored
                               ( let ((old (org-export-format-reference stored)))
                                 ( and (not (assoc old cache)) stored)))))
                         cells)
                        ( when (org-element-property  :raw-value datum)
                           ;;  Heading with a title
                          (unpackaged/org-export-new-title-reference datum cache))
                         ;;  NOTE: This probably breaks some Org Export
                         ;;  feature, but if it does what I need, fine.
                        (org-export-format-reference
                         (org-export-new-reference cache))))
               (reference-string new))
           ;;  Cache contains both data already associated to
           ;;  a reference and in-use internal references, so as to make
           ;;  unique references.
          ( dolist (cell cells) ( push (cons cell new) cache))
           ;;  Retain a direct association between reference string and
           ;;  DATUM since (1) not every object or element can be given
           ;;  a search cell (2) it permits quick lookup.
          ( push (cons reference-string datum) cache)
          (plist-put info  :internal-references cache)
          reference-string))))

( defun  unpackaged/org-export-new-title-reference (datum cache)
   "Return new reference for DATUM that is unique in CACHE."
  ( cl-macrolet ((inc-suffixf (place)
                  `( progn
                     (string-match ( rx bos
                                       (minimal-match (group (1+ anything)))
                                       (optional  "--" (group (1+ digit)))
                                       eos)
                                   ,place)
                      ;;  HACK: `  s1 ' instead of a gensym.
                     ( -let* (((s1 suffix) (list (match-string 1 ,place)
                                                (match-string 2 ,place)))
                             (suffix ( if suffix
                                         (string-to-number suffix)
                                       0)))
                       ( setf ,place (format  "%s--%s" s1 ( cl-incf suffix)))))))
    ( let* ((title (org-element-property  :raw-value datum))
           (ref (url-hexify-string (substring-no-properties title)))
           (parent (org-element-property  :parent datum)))
      ( while ( --any (equal ref (car it))
                    cache)
         ;;  Title not unique: make it so.
        ( if parent
             ;;  Append ancestor title.
            ( setf title (concat (org-element-property  :raw-value parent)
                                 "--" title)
                  ref (url-hexify-string (substring-no-properties title))
                  parent (org-element-property  :parent parent))
           ;;  No more ancestors: add and increment a number.
          (inc-suffixf ref)))
      ref)))

(unpackaged/org-export-html-with-useful-ids-mode)

 ;;  Load the publishing system
( require ' ox-publish)
(message  "Done!")


(message  "Setting customizations...")
 ;;  Customize the HTML output
( setq org-html-postamble t                     ;  use org-html-export-format
      org-html-head-include-scripts nil        ;  Use our own scripts
      org-html-head-include-default-style nil  ;  Use our own styles
      org-confirm-babel-evaluate nil           ;  Don't ask permission for evaluating source blocks
      org-html-html5-fancy t
      org-html-htmlize-output-type 'css
      user-full-name  "tusharhero"
      user-mail-address  "tusharhero@sdf.org"
      org-html-with-latex 'verbatim
      )

( setq org-html-postamble-format
      `(( "en" ,(concat
                 "Author: %a"
                 "
"
                 ;;  Email obfuscation.
                 "email

Why do I use Emacs?

Fri, 29 Mar 2024 00:00:00 +0530

~659 words. ~3 minutes.

tags: emacs programming

I often get asked why I use Emacs, I feel like I have to defend myself because they often hit me the "Why not just use Vim or Neovim?", I plan to send them the reply through this article.

The Beginnings and Past

So let's start from the beginning, according to my git logs (of my Emacs configuration) I started using Emacs in the August of 2023(at least), so it has been 8 months since I have started with Emacs, before this I was using Spacemacs for 4 months as far as I remember, and before still I was on Neovim, Vim and Codium ( Free Vs code basically).

I think it should be noted that I didn't actually configure Vim at all and I just used a distribution for Neovim. The same I did with Emacs through Spacemacs, but I felt that Emacs was worth investing my time into, so I started writing my own Emacs Configuration for Programming and Writing(ECFPAW).

Dissatisfaction with previous editors

I will now try to go to over each.

Markdown didn't just work with previous things

Markdown was just a pain for me, especially making tables was a pain, exporting the documents into formats like PDF, and HTML was painful. And then I switched to org-mode, all these things are literally built in. Why wouldn't I switch to it?

It has come to my notice that Neovim has extensions to do these things, but it still seems inferior to the facilities in Org-mode.

Language Server were a pain with Neovim

I was using a distribution of Neovim but it was still a pain to use a language server in Neovim. In Emacs, I found LSP mode, and later Eglot, to be very simple to use.

What really sold Emacs to me.

What really sold Emacs are two things:

Resilience
Extensibility

If I am going to invest my time into something, I want it to last for at least my life time, I don't want to be in a situation where I invest a lot of time into learning a tool and a few years later it is deprecated and I have to switch to something else.

We have seen this happen recently with Atom, which was often touted as the Emacs successor has been sunset-ted. I can inductively assume that Emacs will not die in the next 5 years by looking its (GNU Emacs) 40 something years, it almost feels like a miracle that this thing is still going strong!

Some of you might feel that Vi also satisfies this condition as it's just as if not more older than Emacs (they were released in the same year 1976). If you are reading this article carefully you might have noticed an inconsistency, I say Emacs is 40 years old but 1976 is 48 years in the past. Yes, because Vi is not used today, but GNU Emacs is still used today, in fact Vim is being replaced by Neovim as more and more people seem to switch to it, so my point about a continuous system is not true for Vi/Vim/Neovim.

I feel the reason for this is the fact that Emacs is very extensible. It by design more extensible than Neovim because it is implemented as a Emacs lisp interpreter, and most of the functionality is implement in Emacs lisp, this means that practically every feature can be implemented in Emacs! So there is no reason for me to use any other text editor when this can do everything! And I have found this to be practically true, here is an example😉.

So this, friends, is why I have become a saint in the Church of Emacs

(well, I technically still use some non-free software, I said that for

comedic effect).