Ashish Panigrahi

Another year gone (my poem)

2026-10-06T00:00:00+00:00

The day arrives every year.
Reminding me of my eternal fear.
Life inches closer to the end.
As it is to be meant.

People celebrate it as an event so joyous.
The day you were born, the festivity so contagious.
But alas, it is yet another year gone.
I'm afraid this thought is what I mourn.

I realize I'm a year older.
Fearful that such a thought is so much colder.
For what is there to celebrate?
Just yet another year that's gone to waste.

This website is now built with Org mode

2026-10-05T00:00:00+00:00

Since moving to Zola as my static site generator, I have had a nice setup for my website. However, a recent update to zola (v0.22 -> v0.23) broke my website (it apparently had something to do with the Tera templating engine that zola uses). This forced me to finally make to move to switching to orgmode as my SSG.

My ultimate goal has always been to build this website purely with emacs and orgmode^[1], and I'm glad now that's the case. Full disclosure however, I did take the help of LLMs to implement this over the weekend. There are still some rough edges to the site, which is why I have this build on a different branch (instead of main) on my website's source repository.

The website is generated via org-publish with the following directory structure for the source code:

.
├── LICENSE
├── Makefile
├── README.org
├── content/
├── lisp/
├── publish.el
├── static/
├── statichost.yml
├── style.css
└── templates/

5 directories, 6 files

The key component is publish.el which exports all of my blogposts (which are orgmode files now) to html files. I also have the htmlize.el file hosted on the git repo for syntax highlighting.

Feel free to peruse the source code of this build if you're interested in the technical details. At its current state, I'm quite happy with how it has turned out. A nice little addition (which is the default behaviour of org-publish) is that I now have a footer entry mentioning the emacs and orgmode version used to build this website!

As is the trend to move all of my computing needs to emacs. ↩

An upgraded workflow on reviewing finished tasks with org-agenda

2026-09-19T00:00:00+00:00

In my last blogpost, I showcased how I review tasks finished over the last seven days. It implicitly assumes that I attend every group meeting^[1] and that the group meeting happens during the same time every week^[2].

In a more practical sense, it would be nice to generalize this workflow. I would like to specify a date, since when completed tasks would be displayed until the current day. This way I would be able to review my finished agenda items since a particular day in the past. This date would typically be when the group meeting last occured, but we are not strictly bound to it.

Implementation in emacs lisp

We write an elisp snippet similar to the one in the previous blogpost.

(defvar pani/last-group-meeting-date nil)

(setq org-agenda-custom-commands
      '(("v" "Finished tasks since last group meeting"
          tags
          (format "CLOSED>=\"<%s>\""
                  (setq pani/last-group-meeting-date
                        (org-read-date nil nil nil "Last group meeting: ")))
          ((org-agenda-overriding-header
            (format "Finished tasks since %s" pani/last-group-meeting-date))
           (org-agenda-archives-mode t)
           (org-agenda-tag-filter-preset '("-emacs" "-personal" "-email" "-misc"))
           (org-agenda-prefix-format '((tags . " ")))
           (org-agenda-remove-tags nil)))))

Most of the config options are similar so I won't be going over in detail. Let's instead point out the differences.

Since we would like emacs to prompt for a date, we use the org-read-date function. We also replace CLOSED>=\"<-7d>\" with CLOSED>=\"<%s>\" with %s being a placeholder for the specified date. For more details on org-read-date, read the official documentation.
The org-agenda-overriding-header is slightly modified to display the text "Finished tasks since 2026-09-16" if 16th September is selected during the date prompt.
We define a variable pani/last-group-meeting-date which stores the value of the date specified. Hence, before the custom org-agenda view is called, it stores nothing i.e. NIL.

To invoke this view, we simply run M-x org-agenda and hit v to get into the view.

Invoking custom org-agenda views (slightly) faster

Just like in the previous workflow, we write another function to invoke this custom org-agenda view and bind it to C-c v to invoke it faster.

  (defun pani/done-items-since-meeting-org-agenda ()
    "Prompt for the date of the last group meeting and show completed tasks since then.
It displays every DONE item closed from the chosen day upto today."
    (interactive)
    (org-agenda nil "v"))

When invoking the view, we are prompted for a date with a pop-up calendar. We select a particular date in the past; Typing "-wed" to select last Wednesday, we are instantly greeted with the following view:

With this, we can review tasks not just from the last seven days, but basically from any day in the past!

Special thanks to Marci for pointing out typos.

I wish I could wake up on time in the morning during winters! ↩
My supervisor is a busy person, which unfortunately requires the group meeting to be rescheduled sometimes, albeit infrequently. ↩

Home isn't home without you (my poem)

2026-08-18T00:00:00+00:00

Home isn't home without you.
The week we spent together quickly flew.
I forgot what it meant to live alone.
Only to feel it with gusto once you were gone.

For a fleeting moment, it felt like my childhood days.
If only, a little longer you could stay.
The week felt both long and short.
But the time spent with you was never for naught.

How I wish I could turn back time.
To relive that week again would be sublime.
I will miss you when you're not here.
But such is life, while I await my dear.

Reviewing finished tasks from last week in org-agenda and emacs

2026-07-26T00:00:00+00:00

Being a PhD student within a research group entails some structure to tracking your progress as you proceed with research. Within the current team that I'm in, we have weekly group meetings where each member presents the tasks that they've completed during the previous week and discusses any issues they might've faced (if any), to our supervisor.

Usually before the meeting, I jot down things that I've finished with pen and paper. But since I'm in the spirit of integrating my workflow with emacs and orgmode, I thought why don't I try implementing this part of my routine also into orgmode.

Enter org-agenda

All my todo items are tracked with org-agenda where I capture every task I need to finish with org-capture^[1].

I have a custom org-agenda view just for viewing my daily and weekly TODO items, events/meetings scheduled at a certain time and tasks that have a deadline associated with them. Suffice to say, this workflow has replaced all my needs for having a calendar over the cloud, be it Google, Outlook, what have you^[2]. The only downside that I haven't figured out (yet) is to incorporate calendar invites that I receive via email, into my org-agenda automatically instead of manually capturing an event into the agenda view.

With this custom agenda view, as I finish tasks and mark them DONE, they disappear from the current view. This is by design. I figured I could just review my completed tasks by visiting the relevant files (tasks.org, meetings.org, etc. in my case). But who wants to sift through all the completed tasks and filter them manually to only note down the tasks completed during the previous week? Why not automate this with the power of emacs?

Elisp snippet that implements this weekly review

The idea is fairly simple. I'd like to look at the tasks that I've completed since the last group meeting. This assumes I review these tasks on the day of the group meeting (which I do currently^[3]).

We simply then instruct orgmode to filter out the DONE items from the last 7 days. The org-agenda-custom-commands variable is what we'll use to define this custom org-agenda view.

(setq org-agenda-custom-commands
      '(("w" "Finished tasks from last week" tags "CLOSED>=\"<-7d>\""
         ((org-agenda-overriding-header "Finished tasks from last week")
         (org-agenda-archives-mode t)
         (org-agenda-tag-filter-preset '("-emacs" "-personal" "-email"))
         (org-agenda-prefix-format '((tags . " ")))
         (org-agenda-remove-tags nil)))))

Let's go over the various config options one by one:

The first line defines the keybinding in the primary org-agenda dashboard and the associated title for the keybinding.
tags "CLOSED>=\"<-7d>\"" is pretty self-explanatory. We filter for items that were completed in the last 7 days.
org-agenda-overriding-header: Simply defines the title of the agenda view.
org-agenda-archives-mode: This is set to t (True) meaning to also look at the archived entries from last week. I typically archive my entries frequently so this is helpful.
org-agenda-tag-filter-preset: I don't want personal tasks appearing in this view, so I remove any items that have the relevant tags.
org-agenda-prefix-format: By default, the agenda view contains information about which file the entries belong to (in my case, it's tasks.org). This appears as tasks: per entry in the agenda which unnecessarily clutters the view.
org-agenda-remove-tags: I don't want to remove the tags of the various entries (they are useful to me) that appear in the right margin. Hence this variable is set to nil (False).

To invoke the view, we can simply run M-x org-agenda and hit w to get into the view. My org-agenda dashboard looks like this:

All the above keys are present in the default view, except my custom views (depicted by j and w keys).

Invoking custom org-agenda views (slightly) faster

For my workflow, I mostly deal with just the two org-agenda views (represented by j and w). It's a good idea to have a global keybinding to quickly invoke these views. Let's define the function and keybinding for it.

(defun pani/done-items-prev-week-org-agenda ()
  "Custom function to immediately jump to my custom org-agenda view."
  (interactive)
  (org-agenda nil "w"))

To invoke the function, we define the keybinding like via a use-package macro:

(use-package org-agenda
  :ensure nil
  ;; Don't need to go through org-agenda template for custom agenda
  :bind (:map global-map
          ("C-c w" . pani/done-items-prev-week-org-agenda)))

I can then just hit CTRL c w to bring up this new agenda view.

That's it! This should make things easier for me during our group's weekly meetings.

Special thanks to Marci and my sister, Alaka Panigrahi for pointing out grammatical errors and typos.

More on this in a future blog-post. ↩
This is fully offline. Between my personal laptop and office PC, I simply use syncthing to sync all my orgmode files via peer-to-peer. ↩
This is perhaps not the best approach but is a good enough starting point for me. ↩

Will you shed tears when I die? (my poem)

2026-06-21T00:00:00+00:00

Will you shed tears when I die?
I envisage on my bed as I lie.
Whence comes such a thought in my mind?
As I feel my life has come to a grind.

Ups and downs make up any life.
I console myself with such thought to be rife.
But why do I feel such deject?
My mind keeps circling as I introspect.

Today I'm here and tomorrow perhaps not.
Such is the nature of life with fraught.
Would you still care enough to cry?
As I head over the horizon and say goodbye.

Setting up offline email for Microsoft O365 with notmuch and emacs

2026-06-07T00:00:00+00:00

Having to deal with Microsoft's outlook has been a growing pain with my computing needs. Of course, this is pertinent only for work email. For personal email, I use Migadu which has good standards for email unlike Microsoft's.

At work, I can only use either the official Outlook webmail or Thunderbird since those are the only clients that are whitelisted by the IT department at my university. Thunderbird is slightly better (it has a few problems of its own but I digress) but I would like to have an offline copy of all my emails, fully searchable with an indexed database provided by notmuch, which uses the excellent Xapian library for indexing. Notmuch is shipped as an emacs package in the form of notmuch.el, which is exactly what I like given that I'm moving most of my computing needs into emacs^[1].

I've taken inspiration from Fergus' excellent blogpost which implements the same in neomutt. The initial setup process is identical to Fergus' blogpost.

It should be noted that notmuch is only a mail indexer. It does not fetch mail, nor does it send mail. Those are handled by isync and msmtp, which are commandline programs.

Access authentication with O365

Since Thunderbird is still allowed to access O365's authentication, we will use the client ID provided from it (this is publicly available from Thunderbird's source code)^[2]. For authentication for IMAP and SMTP, we will use XOAUTH, which is a simple authentication and security layer (SASL) more suited for email clients.

Tools like isync rely on SASL for authentication, for which we'll require an XOAUTH SASL plugin: https://github.com/moriyoshi/cyrus-sasl-xoauth2.

If you're on Arch, then this plugin is installable from the AUR:

paru -S cyrus-sasl-xoauth2-git

If not, then we can build it from source:

git clone https://github.com/moriyoshi/cyrus-sasl-xoauth2
cd cyrus-sasl-xoauth2/
./autogen.sh   # checks for requirements
./configure    # configure (here we use the defaults)
make           # compile
sudo make install     # install for root user

Token generation for OAuth

Microsoft has conditionally allowed API access to clients and the only way to get access for any client is to register the application in the Microsot Application portal, which is something only my org's IT department can do^[3]. Fortunately, we can use Thunderbird's credentials to generate an access token for our purposes.

Another issue that comes up is the finite lifetime of these access tokens (typically an hour or two), which is cumbersome to generate each time one needs to download email. Fortunately, mutt comes with mutt_oauth2.py, a script to help in the automatic renewal of this token. This script helps in decrypting the token file and renewing it everytime it is invoked.

Fetching the initial token is fairly simple but before we do it, there are certain changes that we need to do to mutt_oauth2.py.

Look into the ENCRYPTION_PIPE variable (line 48) and make sure to specify your gpg key. If you don't have one, then generate one:

gpg --full-generate-key

Select the default options (ed25519 cypher if it allows) and make sure that the expiration of the key is set to 0 (no expiration). This makes your life easier but of course for security reasons, this is not a good practice.

Bring up your public key:

gpg --list-keys

Copy the second line (after the pub line) and paste it into mutt_oauth2.py

ENCRYPTION_PIPE = ['gpg', '--encrypt', '--recipient', 'YOUR-GPG-KEY']

After this, look at line 79. This includes a client_id for microsoft. For Thunderbird, the client id is 9e5f94bc-e8a4-4e73-b8be-63364c29d753. Leave the client_secret value as is. It should look like so:

'client_id': '9e5f94bc-e8a4-4e73-b8be-63364c29d753',
'client_secret': '',

Now we are ready to generate the access token. Simply run:

./mutt_oauth2.py OUTPUT_TOKEN_FILE --verbose --authorize

A series of prompts should appear. Select microsoft, localhostauthcode (or authcode), followed by your email address, after which you should automatically be redirected to a browser for adding your credentials for authentication. Doing so, should reveal the access token in your terminal. No need to copy it, it is present in your OUTPUT_TOKEN_FILE which is encrypted. To obtain the decrypted token, we run the script again with just the file name as an argument

./mutt_oauth2.py OUTPUT_TOKEN_FILE

A nice thing is that running this script with the token file also checks for expiry and renews it if necessary. This can be done multiple times without worry.

UPDATE (2026-06-19): About 20 days after I set this up, for whatever reason the token file expired on my personal laptop. I'm not entirely sure what happened but the fix for now was to regenerate the token again. I'll need to debug the exact cause to prevent it from happening again.

UPDATE (2026-07-29): It looks like this problem only appears on my personal laptop as it's not an authorized device and as such, 14 days is the maximum duration before which the token needs to be reauthorized. My office PC is within this "authorized" devices whitelist and thus doesn't need reauthentication after the initial setup.

Offline email setup

Now that we are done with the difficult part, we move onto setting up isync (the binary is called mbsync) which is available in most distributions. This program basically downloads your emails offline and synchronizes it with your email's remote IMAP servers. It supports multiple accounts too. The program is configurable with a ~/.mbsyncrc file^[4]. I highly recommend reading the manual for it via man mbsync. Here's a starting template:

# -- Global defaults
# These will be applied to all accounts

# Create new mail in either location, so if the remote or local has mail
# and the other does not, then create it
Create Both
# never remote mail from either side
Remove None
# Remove messages marked for deletion from the local side on the
# remote. Do not ever delete local if marked for deletion in the
# remote. Prevents admins from deleting one's local mail
Expunge Far
Sync All
SyncState *
CopyArrivalDate yes
# No maximum number of messages
MaxMessages 0

# -- First email account
IMAPAccount university
Host outlook.office365.com
Port 993
User my-username@university.edu
AuthMechs XOAUTH2
PassCmd "~/.local/bin/mutt_oauth2.py ~/.local/bin/TOKEN"
# Use TLS
TLSType IMAPS
SystemCertificates yes
Timeout 10

# A store defines a collection of mailboxes, so we associate the
# remote IMAP mailbox with the account we just configured
IMAPStore university-remote
# Associate the store with our account
Account university

# Where are we going to keep the mail associated with this account
MaildirStore university-local
SubFolders Verbatim
Path ~/.local/share/mail/university/
Inbox ~/.local/share/mail/university/INBOX

# Channel to synchronize everything except "Sent" email
Channel uni-main
Far :university-remote:
Near :university-local:
# Which directories to synchronize
Patterns INBOX "Deleted Items" "Drafts"

# Channel to synchronize "Sent" email
Channel uni-sent
Far :university-remote:"Sent Items"
Near :university-local:Sent

# Group the two channels and sync everything with `mbsync NAME`
Group university
Channel uni-main
Channel uni-sent

# -- Second email account
IMAPAccount personal
...

Once you have everything configured, we can start downloading all our email by running:

mbsync university

The first time mbsync is run, it will take a fair amount of time, since you'll be downloading a lot of email (assuming you've been using your account for a long time). The subsequent runs would be just incremental downloads, so it's much faster.

After navigating to your local Maildir directory (~/.local/share/mail/university in my case), you should see all your emails downloaded and categorized into inbox, drafts, sent, and deleted-items folders.

A way to automate this to run a script periodically. I use systemd-timers where I have a script which is periodically run every 15 mins and notifies me if there's new email (I'll cover this later in the blogpost).

Sending mail via SMTP

Sending email is done via msmtp. It is configured by editing ~/.msmtprc^[5].

defaults
auth on
tls on
tls_trust_file system
logfile ~/.cache/msmtp.log
timeout 10

# -- First account
account university
tls_starttls on
host smtp.office365.com
port 587
auth xoauth2
user my-username@university.edu
passwordeval "~/.local/bin/mutt_oauth2.py ~/.local/bin/TOKEN"
from my-username@university.edu

# -- Second account
account personal

This is fairly self-explanatory. One thing to note is that tls_starttls should be on for this to work. I'm not very familiar with email security protocols like TLS and STARTTLS but from my understanding, STARTTLS is an automatic upgrade (if supported) from the more insecure TLS protocol. TLS however needs to be enabled for any email service, otherwise it won't work.

Now, we can test our configuration by sending email directly from the commandline. Save the contents of a file called example-mail as follows:

From: my-username@university.edu
To: user@example.com
Subject: Hello World

This is a test for msmtp.

And send the email by running:

cat example-mail | msmtp -t -a university

Indexing email offline with notmuch

We have receiving and sending email configured. How about reading and "using" email via an email client. In more technical terms, an email client is called a mail user agent (MUA), which is typically seen in email headers. This includes clients like Thunderbird, Apple mail, neomutt, etc. We will configure notmuch which indexes email and provides an interface for emacs natively with notmuch.el.

Notmuch is entirely tag based. Basic tags exist like unread, inbox, draft, sent but you can customize it with more tags to filter out emails from a particular email address, from a particular range of date, etc. Tags are heavily used and it's a different paradigm of handling email compared to your typical webmail interface. I won't go over the details of tagging in notmuch here for the sake of brevity (to be covered in another blogpost).

When first setting up notmuch, simply run:

notmuch setup

This will prompt you for basic information like your name, email address, Maildir directory, etc. Once this is done, notmuch needs to index your Maildir. Run the following:

notmuch new

This should be fairly fast, even if your Maildir is big. Notmuch is quick like that.

Now you can search an email entry via notmuch search. For example, I can search emails from a particular sender like so:

notmuch search 'from:friend@university.edu'

I would again advise you to go through the man pages (man notmuch-search) for more details.

Emacs setup for notmuch

Simply running M-x notmuch should give you a hello screen, where you can then select tags like inbox, unread to view their respective email. I have a fairly customized config for notmuch.el but below I provide a fairly good starting point for a more minimal notmuch interface^[6]:

;; Notmuch for email
(use-package notmuch
  :load-path "/usr/share/emacs/site-lisp/"
  :ensure nil
  :defer t
  :commands (notmuch notmuch-mua-new-mail)
  :init
  ;; Search
  (setq notmuch-search-oldest-first nil)
  :config
  ; General UI
  (setq notmuch-show-logo nil
    notmuch-column-control 1.0
    notmuch-hello-auto-refresh t
    notmuch-hello-recent-searches-max 20
    notmuch-hello-thousands-separator ""
    notmuch-hello-sections '(notmuch-hello-insert-saved-searches)
    notmuch-show-all-tags-list t)

  ; Search
  (setq notmuch-search-result-format
        '(("date" . "%12s  ")
          ("count" . "%-7s  ")
          ("authors" . "%-20s  ")
          ("subject" . "%-80s  ")
          ("tags" . "(%s)")))
  (setq notmuch-tree-result-format
        '(("date" . "%12s  ")
          ("authors" . "%-20s  ")
          ((("tree" . "%s")
            ("subject" . "%s"))
           . " %-80s  ")
          ("tags" . "(%s)")))
  (setq notmuch-show-empty-saved-searches t)

  ; Tags
  (setq notmuch-archive-tags nil ; I don't archive email
    notmuch-message-replied-tags '("+replied")
    notmuch-message-forwarded-tags '("+forwarded")
    notmuch-show-mark-read-tags '("-unread")
    notmuch-draft-tags '("+draft")
    notmuch-draft-folder "university/Drafts"
    notmuch-draft-save-plaintext 'ask)

  ; Email composition
  (setq notmuch-mua-compose-in 'new-window)
  (setq notmuch-mua-hidden-headers nil)
  (setq notmuch-address-command 'internal)
  (setq notmuch-address-use-company nil)
  (setq notmuch-always-prompt-for-sender t)
  (setq notmuch-mua-cite-function
    'message-cite-original-without-signature)
  (setq notmuch-mua-user-agent-function nil)

  (setq notmuch-show-relative-dates t)
  (setq notmuch-show-all-multipart/alternative-parts nil)
  (setq notmuch-show-indent-messages-width 0)
  (setq notmuch-show-indent-multipart nil)
  (setq notmuch-show-part-button-default-action 'notmuch-show-view-part)
  (setq notmuch-wash-wrap-lines-length 120)
  (setq notmuch-unthreaded-show-out nil)
  (setq notmuch-message-headers '("To" "Cc" "Subject" "Date"))
  (setq notmuch-message-headers-visible t)

  :bind
  ( :map global-map
    ("C-c m m" . notmuch)
    ("C-x m" . notmuch-mua-new-mail) ; override `compose-mail'
    :map notmuch-search-mode-map
    ("/" . notmuch-search-filter) ; alias for l
    ("r" . notmuch-search-reply-to-thread) ; easier to reply to all by default
    ("R" . notmuch-search-reply-to-thread-sender)
    :map notmuch-show-mode-map
    ("r" . notmuch-show-reply) ; easier to reply to all by default
    ("R" . notmuch-show-reply-sender)
    :map notmuch-hello-mode-map
    ("J" . notmuch-jump-search)))

You're free to look at my init.el for my own customization for notmuch.el.

Automating email synchronization with systemd timers

Let's automate the email sync to happen every 15 mins (or whatever frequency you prefer). First we create a shell-script to download email via mbsync and also index the email with notmuch. Let's name it it syncmail.sh and place it in $HOME/.local/bin/.

#!/bin/sh
set -eu

# Set environment variable for notmuch config file
export NOTMUCH_CONFIG="$HOME/.config/notmuch/notmuch-config"

mbsync university

before=$(notmuch count --lastmod '*' | cut -f3)
notmuch new > /dev/null

query="lastmod:$((before + 1)).. and path:university/**"
count=$(notmuch count "$query")

if [ "$count" -gt 0 ]; then
    body=$(notmuch search --format=json --limit=5 "$query" \
           | jq -r '.[] | "\(.authors): \(.subject)"')
    notify-send "New mail: $count" "$body"
fi

In addition to downloading email and indexing, the script also notifies through notify-send if there's new email along with a sender and subject in the notification. Make sure to make the script executable with

chmod +x ./syncmail.sh

Then we write the systemd script to run this script periodically. First we create a syncmail.service file in $HOME/.config/systemd/user/:

[Unit]
Description=Sync mail with mbsync and index with notmuch

[Service]
Type=oneshot
ExecStart=%h/.local/bin/syncmail.sh

Then we create a timer file (make sure it is named syncmail.timer) for actually running the script every n minutes.

[Unit]
Description=Run syncmail every 15 minutes

[Timer]
OnBootSec=2m
OnUnitActiveSec=15m
Persistent=true

[Install]
WantedBy=timers.target

The advantage over cronjobs is that if your system is asleep or shutdown, then booting up accomodates accordingly and runs the script after m minutes (2 minutes in my case).

Finally we enable the script with systemctl:

systemctl --user daemon-reload
systemctl --user enable --now syncmail.timer

Concluding remarks

Now you should have a working setup for using offline email for Microsoft's O365. This is fairly minimal but if you'd like to have encrypted emails, addressbooks, etc., please take a look at the original blogpost from Fergus.

A basic emailing etiquette I like to follow is to use plaintext as opposed to html. Read more on why this is better.

Special thanks to Marci for pointing out grammatical errors and typos.

It's like the old adage from Vi advocates, "Emacs is a great operating system, lacking only a decent text editor". Although the latter part I would disagree with. ↩
I just found out that Mozilla has made it very convoluted to find the source code and build Thunderbird locally. It uses mercurial instead of Git (in this day and age?). Relevant docs are here. ↩
Even after asking countless times, they've rejected my request to include notmuch/emacs into the allowed clients list. Ah well, here we are. ↩
Personally, I dislike that my $HOME directory gets cluttered with config files that don't respect the XDG specifications. I set it to $HOME/.config/mbsync/mbsyncrc by exporting the variable MBSYNCRC. ↩
Same issue with this. I fix it to be at $HOME/.config/msmtp/config. ↩
The default interface is too noisy for me, so I disable a lot of the bells and whistles. ↩

New update for this website

2026-05-26T00:00:00+00:00

It has been a while since I updated my website. Over the years, I've grown to like minimal yet aesthetic websites which comply with legibility standards.

Recently, I came across the excellent Bear blog and was enamored by its simplistic yet appealing stylistic nature. I think it's a great platform to get started with writing your own blog page. But anyway, I was more interested in the stylesheet rather than the actual method of publishing a website. After diving into this rabbit hole of various bear blogs, I was pleased to come across the Bearming theme made by Robert Birming.

Along with this, comes Zola which is yet another static site generator. For now, I've become so accustomed to the boilerplate that SSGs provide that it's hard to move onto something truly minimal^[1]. But like they say perfectionism is the enemy of progress, and so here's another attempt at updating my website more frequently^[2].

Now that the stylistic nature of this website is to my liking, I can write more blogposts about things that interest me. Stay tuned!

UPDATE (2026-10-05): My website is now fully built with orgmode's org-publish and emacs! Check out the blogpost.

Hopefully I can move my entire website to being built by orgmode and emacs some day. ↩
Depending on how much free time I can get as a PhD student. ↩

Hope (my poem)

2025-11-18T00:00:00+00:00

A shining light in the tunnel of darkness.
That's how I see hope, with a longingness.
Sometimes good and sometimes bad,
But somehow makes me glad.

Is it hope that I'm looking for?
Like a drop of water, in a large desert outdoor.
Is it just something made up?
A lie told even after I slipup.

Hope is a dangerous thing.
The results can feel like a swing.
But is it enough to justify my life?
The way I'm living, with so much strife.

I keep clinging to this hope.
Even with my life being a downward slope.
Sometimes I fear it won't be there.
At that point, would I still care?

I find myself in an abyss.
At times, devoid of any bliss.
Hope is the only thing in my mind.
Alas it is hard to see, perhaps I left it too far behind.

Bypassing the storage limit on Zotero with Syncthing

2025-03-22T00:00:00+00:00

Recently, I found out about this neat little trick to bypass the storage limit on Zotero for PDFs. Currently on the "free" tier there is a limit of 300 MB which fills up pretty quickly when you're doing serious research. This guide helps bypass this limit (subject to your computer's storage).

The current pricing model. Not bad but you don't need it if it's just for personal use.

The prices are there for if you'd like to store associated PDFs on the cloud and makes sense if two or more people would like to share the same bibliography data. What this blogpost helps with is storing the files locally and syncing them peer-to-peer.

Best part is it's free!

Prior situation

Usually if you're employed at a university/research institution, the institute has a subscription to various journals. I would use this with Zotero, strictly only storing the metadata and journal links and opening them on the browser. The PDF can then be downloaded if you're on the institute's intranet.

Storage location for PDFs

On Linux^[1], by default I believe Zotero creates a directory ~/Zotero/ for storage of files, notes and metadata. I usually create my own custom location for the directory, ~/.zotero/ in this case as I don't like having my home directory cluttered^[2].

To change this, go to Edit -> Settings -> Advanced and under "Data Directory Location" you can specify a custom path.

Dialog box for specifying custom location for Zotero directory.

Now assuming you already have a sizeable zotero database, we go to this location and are interested in the ~/.zotero/storage folder. This is where the PDFs are stored.

Changing a few settings

Now, by default Zotero syncs all your files to the cloud. We don't want that. To disable it, go to Edit -> Settings -> Sync and under File Syncing uncheck both "Sync attachment files in My Library" and "Sync attachment files in group libraries using Zotero storage".

Uncheck both the boxes.

Now that we have unchecked the boxes, one can simply save the PDFs as we like and use it on their computer. But what if we need to access files on a different computer? That's where peer-to-peer syncing comes in.

Syncing with Syncthing

Syncthing is an excellent piece of software. As described on their website:

Syncthing is a continuous file synchronization program.

Basically it helps sync files between different computers in a peer-to-peer fashion.

Quickstart guide

I would highly recommend the official user-guide for using syncthing. However, the following covers a quick and brief guide to getting syncing setup with Zotero.

Launching syncthing in a terminal opens up localhost:8384 on your web browser and you're greeted with the GUI.

Syncthing GUI

The GUI shows three components, two of which we are concerned with. On the left are the folders that are synced. The right bottom section consists of the devices to which certain folders are being synced. In my case, I have the zotero storage folder synced with my office PC and some other folders synced with my Android phone.

The "Add Folder" button is a good starting point. Clicking it leads us to a dialog box asking for a folder label and a folder path. The latter is important. For now, just ignore the folder ID variable. It is auto-generated by syncthing and is meant to let syncthing know which folders to sync across different computers based on this ID.

Adding folder for syncing.

Now, just set the folder path to ~/.zotero/storage (or whatever is the custom folder path you've set in Zotero) and click save.

Adding remote device

On the secondary device that you'd like to access your PDFs on (laptop or perhaps a desktop at your office like me), then you need to launch syncthing on the remote device and add it on your main computer by clicking "Add Remote Device" at the bottom right corner in the GUI.

The device can be added either via a device ID or via a QR-code, which is accessible under the "Actions" tab and clicking "Show ID".

Accessing QR code for current device.

Follow similar instructions on the remote device for setting up a sync folder (should be empty as for the first sync, we're really transferring PDFs from the main device to the remote one). Make sure to have the same path in your Zotero settings on the remote device!

After adding the remote device, we need to share the folder we had set with the remote device. To do this, simply go to the zotero-storage folder under the "Folders" section and click edit. This will bring up a dialog box that we had previously edited. Under the "Sharing" tab, check the box for the added remote device^[3].

And just hit save.

Sharing the folder with remote device.

If you have everything setup properly, the folder should get synced across both the devices and you should be able to access the PDFs in both these device! Of course, you can add more devices if you'd like.

I've been extremely happy with this setup and I hope it's useful to you as it has been for me. Thanks to my friend Marci who introduced me to the idea.

This guide assumes you're using Linux but I see no reason why it cannot be adapter for Windows and macOS. ↩
To actually keep your ~/ uncluttered, the best approach would be something along the lines of ~/.local/share/zotero which is XDG_DATA_HOME according to XDG standards. ↩
Don't worry about the "enter encryption password". You only need it if you're concerned with security and would like to have encrypted folders. I don't really care about that for zotero so I leave it unchecked. ↩

When did I stop being a child? (my poem)

2024-06-19T00:00:00+00:00

When did I stop being a child?
It's been so long, but I used to be quite beguiled.
While I reminisce the days of not caring about the world.
I wonder, when that child stopped being one, as an adult labelled.

Perhaps it was when my interests changed.
Things that I used to like, now feel estranged.
Oh, how I wish I could go back to those simpler times.
That child exists no more, but an adult begrimed.

Carefree is the emotion I took for granted.
Now that I'm older, responsibilities have been handed.
I remember a time when I used to run wild.
Oh, but when did I stop being a child?

As I grow old, my anxiety only becomes stronger.
Is adulthood really supposed to be this way, with nothing more to offer?
Alas, it is too late now to think about a time bygone.
But the only way forward, is to look ahead and march into the unknown.

What is my purpose (my poem)

2024-04-21T00:00:00+00:00

What is my purpose but a tiny speck on this big blue dot?
Is it already decided or do I get myself taught?
I do wonder how the rest of my life shall continue.
Will it be the same things I now pursue?

Family it is for some people.
For others, it is their career to excel.
But does it matter in the end?
Perhaps the greater reason is to make oneself enlighten.

Often I find myself asking such questions.
I keep looking for entities of substance
in this rollercoaster that is life.
What can I do to make it more rife?

For far too long I've been looking far away.
Always fearing that my life might go astray.
Is it deep down something more precious?
Only to find myself asking, "what is my purpose?".

Switching to GNU Emacs

2024-04-14T00:00:00+00:00

Over the past five years, I've been using Vim (well NeoVim specifically) for all of my text editing needs ranging from tinkering with config files, shell scripts, to writing this website, making LaTeX reports and theses, etc. The paradigm of modal text editing that is Vim, just feels right. The user communicates exactly how text needs to be edited. For instance: delete all characters until a specific character appears? Done. Only delete lines in the file that cover certain patterns? Built-in regex has you covered! The point is, once you understand how modal editing works, any other form of text editing feels like it's from the stone ages.

Now you might ask, why am I switching to GNU Emacs, the opposing contender to Vim in the well known editor war? Well, the more "silly" reason is that it gives me an opportunity to learn a new piece of software, understand it's inner workings, etc. The more pragmatic reason is that, like any rivalry, both sides have their pros and cons. GNU Emacs presents itself as a truly hackable editor in any way the user desires. This is thanks to the editor being written and configured in Emacs lisp, a dialect of the Lisp family of languages. Vim on the other hand is written mostly in C but is configured in an obscure language that is Vimscript. The advantage with Emacs lisp is that one can write not only specific functions to help in any form of text editing and beyond (one of the charms of Emacs) but also supplements more experienced users in contributing to the core development of Emacs. This appeals to me from a FOSS perspective as I truly believe that free software development being run by volunteers should be tightly knit with its user community. This helps not only in raising issues with the software better but also in users contributing to the development.

This truly hackable experience, presented by Emacs also benefits in the form of tasks that are not necessarily based around text-editing. Thanks to the wonderful community, Emacs boasts a wide-range of well-written packages such as org-mode (Task management system with a markup style of its own) and Magit (A Git porcelain inside Emacs). One of the primary reasons I've decided to switch is due to org-mode (which I intend to cover in detail in subsequent blog entries).

Some people might argue that Emacs goes against the UNIX philosophy of minimalism and "doing one thing right". Technically Emacs is more of a Lisp environment than a text editor, or like the more famous vim adage: "Emacs is a great operating system, but it lacks a good text editor". I cannot really comment here because I'm still very new to Emacs but the quote does hold some truth. Emacs (atleast from my first impressions) has esoteric keybindings which are completely foreign to new users let alone someone coming from a vim background. Ctrl and Alt (known as Meta in Emacs parlance) are the most common keys which form part of the key-chord style of using emacs. These keys obviously are placed at positions on a standard QWERTY keyboard layout that when used frequently leads to the more infamous Emacs pinky which is basically repetitive strain injury (RSI). For this reason, I will be using emacs with Evil which is the Vi-emulation package in emacs, atleast until I get the hang of working with Emacs before perhaps trying the stock keybindings (which apparently most of the emacs community adheres to).

Relevant xkcd

For the next couple weeks I will try to steadily convert to using Emacs and hopefully perform all of my computing needs with emacs in the not-so-long future. This blog post is mainly for me to make this commitment. As a first step, this blog entry is written entirely in Emacs.

Easy fix for F4 mute LED light on ThinkPad laptops on GNU/Linux

2023-09-05T00:00:00+00:00

Recently I purchased a ThinkPad E14 Gen 5 laptop after spending 5 years with my previous workhorse machine, the HP Pavilion 14 with an Intel i5 (4 cores) CPU. The upgrade is quite significant, coming with an eight core AMD Ryzen 7 CPU... but I digress.

The Problem

With modern day laptops, often there are backlit keys on certain media keys like mute sound, mute mic, airplane mode and so on. The light being switched on, for obvious reasons indicates that the particular function is in operation. This is easy on Windows for which these machines are always tested against^[1].

Similarly, macOS works well on Apple devices. With GNU/Linux^[2] however, almost all machines work but the tiny quality of life improvements like those media key lights can be a hit or miss.

As usual, I went ahead and installed Arch Linux on my machine with dwm as my window manager. After the installation and a test drive of my laptop, I see this...

The annoying led being always ON

At first I thought perhaps it's a driver issue but all my drivers were up-to-date. Looking through the Arch wiki didn't help with the issue. Knowing the vibrant thinkpad community, I ended up posting about my problem on r/thinkpad.

Simple Fix

I'd much rather have the backlight fully off than have it functional. So, a fellow redditor let me know to check for the output in a particular system file:

~: $ cat /sys/class/leds/platform::micmute/brightness
1

'1' here represents the light in the ON state, which is exactly the problem! ~~Changing the value to '0' in the file instantly fixes the problem!~~ Changing it to '0' only fixes it temporarily until the next time the machine is booted up. A rather simple "hack" is to make this change every time the user logs into the machine. This is done simply through the .xprofile or .xinitrc file (most people would use .xinitrc) by adding the following line in said file:

echo "0" > /sys/class/leds/platform::micmute/brightness

This line simply replaces whatever the file previously had, with '0'. This works rather well until I find a more permanent solution.

Edit

Unfortunately, the above method doesn't work anymore. I'm not exactly sure what changed but apparently it isn't supposed to work in the first place simply because /sys/class/leds/platform::micmute/brightness isn't a real directory.

In any case, here's an updated method for the same that is slightly more involved. It is adapted for any Linux distribution running systemd. For other init systems (openrc, runit, etc.), I assume it's fairly simply to make the relevant changes.

Create a shell script disable-mute.sh in your preferred directory (~/.local/bin/ in my case) containing the following:

#!/bin/sh

echo 0 | tee /sys/class/leds/platform::micmute/brightness

With root privileges, create a file disable-mute.service in /etc/systemd/system/ with the following content^[3]

[Unit]
Description=Disables the annoying mute light on keyboard
After=multi-user.target

[Service]
ExecStart=/bin/sh /home/ashish/.local/bin/disable-mute.sh
Type=simple

[Install]
WantedBy=multi-user.target

Simply run sudo systemctl enable disable-mute.service and the LED should turn off the next time you boot up your machine.

Late 2024 Update: This method works so far for the 6.6-LTS Kernel, NOT the bleeding edge one.

The travesty being that laptop manufacturers being the profit oriented businesses that they are, cater to the masses which unfortunately sides with malicious, proprietary garbage like Windows. ↩
Technically Linux is the kernel and not the operating system (the rest is supplied by the GNU operating system sans its own kernel). Here is a better explanation. ↩
See here for a detailed tutorial on writing systemd service files. ↩

Hello, World in Qiskit

2021-07-16T00:00:00+00:00

Qiskit is a python SDK for simulating and running quantum algorithms on real quantum computers. As mentioned on qiskit.org:

Qiskit [kiss-kit] is an open-source SDK for working with quantum computers at the level of pulses, circuits and application modules.

I plan on writing a series of tutorials on getting started with quantum computing using qiskit, as I learn as well. Like any other programming tutorial, we start with a simple "Hello, world" program.

Measuring a quantum state

With conventional computers, the simplest program that one could perhaps make is printing out "hello, world". However, in contrast to this, in quantum systems, we go ahead and measure a quantum state (this seems to be the most rudimentary but complete program in quantum terms). Let's proceed to do just that!

Defining a quantum state

We import the necessary modules from Qiskit for this operation. To define a quantum circuit, we require the classes QuantumCircuit, QuantumRegister, ClassicalRegister and define a state variable psi as

\[ | \psi \rangle = \frac{1}{\sqrt{2}} \begin{pmatrix} 1\\ 1 \end{pmatrix} \]

Notice that the state $| \psi \rangle$ is normalized. This is important, otherwise we'll end up with an error.

from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from math import sqrt

# define an initial state
psi = [1/sqrt(2), 1/sqrt(2)]

We then define a function prepare() which takes two parameters: a QuantumCircuit object named qc and the initial state psi. Remember that the quantum circuit that we define, only uses 1 qubit (notice the vector representation of $| \psi \rangle$).

def prepare(qc, psi):
    qc.initialize(psi, [0])     # [0] indicates the zeroth index (or) the first qubit

Python by default, calls by reference, so we don't have to worry about returning anything from prepare().

Building a quantum circuit

Let's proceed with making an actual quantum circuit. For this, we define a QuantumRegister object qr, which stores the qubits and a ClassicalRegister object cr which stores the measured values of those qubits.

qr = QuantumRegister(1)
cr = ClassicalRegister(1)

Combining the two registers, we now make a quantum circuit:

qc = QuantumCircuit(qr, cr)

Initializing and measuring the qubit

We then call our function prepare() to initialize the first qubit (the only qubit) of our quantum circuit qc.

prepare(qc, psi)

How do we go about measuring our state? That's where the ClassicalRegister object cr comes in. We use the measure method under the qc object to actually measure the qubit.

qc.measure(qr[0], cr[0])

The above syntax generally means that we're measuring the state of qr[0] (the first qubit) onto the classical register cr[0] where we store the measured value.

Visualizing the circuit

Ok so all of this is nice, but one can only describe so much. Let's see how our circuit actually looks like after applying the above operations. For this, we use the draw() method with the matplotlib backend.

>>> qc.draw(output='mpl')

Choosing a backend for measurement

To measure the qubit and store the result in the classical register cr, we use the qasm_simulator backend. As we know from basic quantum mechanics,

from qiskit import Aer
backend = Aer.get_backend('qasm_simulator')

We then transpile our circuit for the qasm_simulator backend to understand and execute the circuit.

from qiskit import transpile
qc_compiled = transpile(qc, backend)

Now, we simply execute the circuit and gather the measurement results.

job = backend.run(qc_compiled, shots=1024)  # shots is the number of times we run the experiment
results = job.result()

We store the value of the result object and can further access the number of times we end up with a certain value of expected outcome with the get_counts() method.

counts = results.get_counts(qc_compiled)
print(counts)

{'0': 518, '1': 506}

Here we end up with a dictionary of key values '0' and '1', which indicate the following quantum states:

\[ | 0 \rangle = \begin{pmatrix} 1\\ 0 \end{pmatrix} \qquad | 1 \rangle = \begin{pmatrix} 0\\ 1 \end{pmatrix} \]

As expected, we get a 50-50 distribution of the states $|0\rangle$ and $|1\rangle$, since our starting state was $|\psi\rangle$. We can also calculate this probability via the inner-product,

\[ |\langle 0 | \psi \rangle|^2 = \frac{1}{2} \qquad |\langle 1 | \psi \rangle|^2 = \frac{1}{2} \]

Let's visualize this in the form of a histogram. For this, we import the plot_histogram function.

>>> from qiskit.visualization import plot_histogram
>>> plot_histogram(counts)

You can find the entire script in this gist.

Font Rendering in Firefox

2021-05-30T00:00:00+00:00

If you're on a *nix system and compare the fonts on chrome and firefox, you'd notice the difference. The fonts on the latter just look... off, or atleast that was the case on my system.

My personal odyssey

Recently I had made the switch from firefox to brave, for the naive reason that fonts were just rendered better (and LaTeX looks like it) on it (being a chromium based browser). However, I really missed the customizability and other nifty features of firefox. It just felt like home. I knew for sure that I'm missing something, because surely firefox couldn't be responsible for messing fonts, right? (atleast I hoped).

On firefox, you may have come across the font settings that look something like this:

My past self would unselect the option Allow pages to choose their own fonts, instead of your selections above, just so that I can have my custom fonts rendered. But oh boy, would that turn out disastrous to say the least. I visit a good number of websites that render math equations in TeX, but with this setting turned off, LaTeX looked more like some flunky '90s PC trying to render math.

What was the fix you might ask? Well, just select the option that I had unselected earlier. But this would bring that the atrocious fonts back on many websites.

The fix

I later came across this blog post where I got to know that firefox depends on an OS-level font configuration called fontconfig and is located at ~/.config/fontconfig/fonts.conf.

Create a fontconfig file

If you don't have one, just create it at the specific location.

<?xml version='1.0'?>
<!DOCTYPE fontconfig SYSTEM 'fonts.dtd'>
<fontconfig>
    <alias>
        <family>Helvetica</family>
        <prefer><family>IBM Plex Sans</family></prefer>
    </alias>
    <alias>
        <family>sans-serif</family>
        <prefer><family>IBM Plex Sans</family></prefer>
    </alias>
    <alias>
        <family>monospace</family>
        <prefer><family>DejaVu Sans Mono</family></prefer>
    </alias>
</fontconfig>

A lot of websites these days use Helvetica as their serif font, and firefox will fallback to a specific font if Helvetica is not found. By default, this fallback seems to be Nimbus Sans, which is not pretty to say the least. This is where fontconfig comes in.

The above XML file tells firefox that, "Hey! If you're trying to render Helvetica, just use IBM Plex Sans", and similar font rules for sans-serif and monospace fonts.

The result

Daniel

The cooler Daniel

I was really happy when I came across this fix! and I hope this has helped you as well.

Intro to Public-key Cryptography

2020-07-20T00:00:00+00:00

We have all heard fancy jargon like "encryption", "cryptography" and what not, but what do these terms actually mean? In this article, I attempt to give you a brief introduction to the world of cryptography and how in particular, public-key cryptography, a popular means of encryption works.

In layman terms, cryptography is the study of securing messages between two parties without a third party knowing what the message is. Encryption is the process of securing these messages.

Think of encryption as a process which is easy to do in one direction but rather difficult to do in reverse. One such example is colour mixing. One can mix various colours and make a mixture out of it. However, if you ask another person, it would be almost impossible to tell the constituent colours from the mixture.

The barebones method - symmetric encryption

The most basic and easy to understand method is the symmetric encryption method. It basically involves the following: Alice, who wants to send a message; Bob, who receives the message; and a secret key used to encrypt the message (essentially turning the message into gibberish).

Alice has a message, encrypts the message using the secret key, sends the message. Bob now decrypts the message using the same secret key and reads the message. This way during the process when the message is sent, even if a third party gets a hold of the message; they cannot read the message since they do not have the secret key.

Caveats

The above method has a major flaw, which is that both the parties must have a common key. That means that the key to be used for encryption must be decided upon by the two parties beforehand. So the two parties have to meet at a place or send the key to the other through some means which isn't secure, unless one encrypts this key information which requires another key.

A better method - asymmetric encryption

Asymmetric encryption AKA public-key cryptography involves the same scenario as that of symmetric encryption, the only difference being that instead of one secret key, two keys are used (called a key pair). Let them be key A and key B.

Let us use the same scenario as before: Alice wishes to send a message; she encrypts it with key A and sends it to Bob; he receives it and decrypts it using key B. Note that there was no exchange regarding the information of the keys themselves. Key A cannot be guessed from key B and vice-versa however they are linked in such a way that a message encrypted with key A can only be decrypted with key B and a message encrypted with key B can only be decrypted with key A.

Real-world implications

When using asymmetric encryption, a key-pair is generated i.e. a public key and a private key.

The public key is made public (who knew!) and is published everywhere, on websites, posters and so on. The private key is kept to yourself. Any messages intended for you could be then encrypted using your public-key that only you can decrypt since you have the private-key.

What about the other way round? You could encrypt a message that you wish to send, using your private-key. But then you might ask, why should I encrypt a message that can be decrypted using my public-key since anyone can decrypt the message? (since you've made your public-key, public)

Signature algorithms

By encrypting the message using your private-key, one can know that the message is authentic since it can be decrypted using your public-key meaning, it must have been encrypted using your private-key which only you have access to.

A proper communication

So the best way to communicate using this protocol would be as follows: Alice has a key-pair and Bob has a key-pair. Alice wishes to send a message; she encrypts it using her private-key ensuring that the message is authentic and then encrypts it again using Bob's public key ensuring that only Bob can read the message. Bob upon receiving the gibberish decrypts it using his private-key and then once again using Alice's public-key establishing a secure channel for communication.

Note that in this method no keys were exchanged, in fact, Alice and Bob might not have even met before and this method still works. Isn't that amazing?

Disclaimer

I understand that I have over-simplified things. This post is only meant to get a brief overview of encryption. For a better understanding refer the Crypto 101 textbook linked below.

This post was inspired by the book, Crypto 101 by Laurens Van Houtven and this video from the YouTube channel Computerphile where Dr. Robert Miles explains about public-key encryption.

Lastly, I would like to end this post with a quote from Bruce Schneier:

There are two kinds of cryptography in this world: cryptography that will stop your kid sister from reading your files, and cryptography that will stop major governments from reading your files.