DeepakNess - Blog

Building CogSend: A Self-Hosted Social Media Scheduler

2026-09-23T09:09:51Z

I have been using Typefully for a long time and it is genuinely great, but it supports a fixed set of platforms and I wanted to decide that for myself. So I built my own. Say hello to CogSend, a self-hosted social media scheduler.

CogSend is open source under the MIT license and it runs on your own free Cloudflare account. There is no monthly fee and no account with me, and your platform credentials stay in your infrastructure. It currently supports Mastodon, Bluesky, LinkedIn, Threads and X with more platform support coming soon.

What it can do

The main idea is, you write a post once, then customize it per platform if you want. There is a Global tab plus a tab for each platform you override, so the X version can stay short while the LinkedIn version says the same thing at length. If you paste a long draft, it splits into a thread that fits the tightest platform you selected, counted the way that platform counts.

Publish now or schedule: Every destination reports its own result, so one platform failing does not take the rest down with it.
Retries take care of themselves: Retryable failures back off and try again a few times. If a platform keeps refusing (sometimes, happens with Threads), the post parks under Failed with the reason, and you can fix it and retry.
Manage it all from Posts: Cancel or reschedule a queued post without opening it, or retry only the destinations that failed.
Images and links: Supports up to four images per post with alt text for each one and preview cards for links.
Insights: Published against failed over 7, 30 or 90 days, bucketed in your own timezone, with failures grouped by reason instead of a wall of API errors.
Locked down: One admin account with an authenticator app, credentials encrypted at rest, and an API key for scripts, Shortcuts and cron jobs.

How to install

You need Node and a Cloudflare account with Workers access, D1 and R2 available. And the whole install process is just two commands:

git clone --depth 1 https://github.com/cogsend/cogsend.git cogsend
cd cogsend && npm install && npm run setup

The setup does everything – creates the database and the bucket, generates the secrets, applies the migrations, deploys the Worker, and then signs in once against the live site to prove it works. At the end just open the final URL it prints, scan the QR with an authenticator app, save the backup codes, and start connecting your social accounts.

The Cloudflare free plan is enough for a personal instance. By the way, R2 does ask for a payment method on file even on the free tier, but the first 10 GB each month are free.

I think, it's more than enough for a single user, no?

Why I built it

Every new post and note I published went out through a small script to the same two platforms. It worked, but I wanted per-post control over where things go, and room to add the platforms I actually use. That is the part CogSend fixes, and now the accounts and the scheduling are mine to change.

I already self-host a few other things, like this website running from a Raspberry Pi, so putting the scheduler on infrastructure I control felt natural, and the best thing is I loved the process of building it.

What's next

First, I will be fixing the documentation and I want the setup to be clear enough that nobody has to read the repo to understand it. And I will record a few short videos for the parts that are easier to show than to write.

After that, will focus on adding more platforms – Instagram, TikTok and YouTube are the ones I am thinking about. Along with these, I'm thinking about more integration options as well.

These are early thoughts though, not the final roadmap.

The code is on GitHub and the site is cogsend.com. It is MIT licensed, so fork it and change whatever you want, and send PR as well.

That's it.

Serving a Website from a 1 GB Pi 4B on Home WiFi

2026-09-13T22:00:16Z

I have a Raspberry Pi 4B at home on WiFi, and it serves a public website. It is a Rev 1.5 board with 4x Cortex-A72 at 1.8 GHz, 1 GB of RAM, a 64 GB microSD card and Debian 13 (trixie). Nothing is forwarded on my router, no ports are open, and my home IP address is never published.

The page is live at pi.deepakness.com, and it is about the machine serving it. You get live readings for CPU, memory, temperature, disk, network and WiFi signal, an hour of history, an availability record with the state of every service, the home connection measured four times a day, and how many people are reading right now.

The path from the internet to the Pi

The Pi sits on my home WiFi as a normal client.
Caddy serves the site files on 127.0.0.1:8080, which exists only inside the Pi.
A Cloudflare Tunnel dials out to Cloudflare and holds that connection open.
Cloudflare publishes the local address as a subdomain of mine, with TLS handled at the edge.

Caddy listens on localhost only, so nothing on my network can reach the site directly, and the tunnel is the only way in. There is no port forwarding on the router, no static IP, and no dynamic DNS record to keep updated.

I had the tunnel pattern written down earlier when I was looking at ways to publish local apps, and the feed reader that runs on this Pi uses the same route.

Getting in without opening SSH

Tailscale is the other half of this setup. The Pi is on my tailnet, which is a private network between my own devices, and it is how I open a shell on the Pi or reach anything else at home from anywhere. It runs as a system service and is not in the serving path at all. The website would work without it, and the admin access would work without the tunnel.

Port 22 is never exposed to the internet, and I still get a terminal on the Pi from basically anywhere.

What Caddy does

The config is mostly security headers and caching. These are the parts that matter, minus the headers:

:8080 {
	bind 127.0.0.1

	@page path / /index.html
	handle @page {
		header Cache-Control "public, max-age=0, s-maxage=60"
		file_server
	}

	@live path /hits.json /uptime.json /speedtest.json
	handle @live {
		header Cache-Control "public, max-age=0, s-maxage=15"
		file_server
	}

	handle /hit {
		respond 204
	}
}

The page is cached at the edge for 60 seconds and the data files for 15, which is just longer than the collector's sampling interval. The numbers stay seconds behind the Pi without the Pi answering every poll from every open tab, and the page's own polls still carry no-store, so those do come here.

/hit is one request per page load, answered with an empty 204 and never cached. That is how page views are counted. Counting them from the access log stopped working once the page was cached at the edge, since the Pi only saw cache fills and the counter advanced about once per edge location per minute, whatever the size of the audience.

That caching is what got it through the afternoon it was shared. Four IP addresses and later much more fetched the page in a loop, the combined peak reached 1,028 requests per second, and the first version of this setup crashed badly.

However, the same board then took 91 million requests in around 15 hours, with 85 million stopped at Cloudflare and 2.76 million served by origin, and it still stayed up.

What keeps it running

Caddy, the collector and the speed test run as systemd user services, symlinked into ~/.config/systemd/user/ from the project. And changes are committed in the repo on the Pi, then the affected unit restarts.

Each service has a memory cap, because memory is the thing that actually runs out on a 1 GB board:

MemoryMax=256M
MemoryHigh=192M
Environment=GOMEMLIMIT=192MiB

Here, Caddy and cloudflared are both Go, and Go holds on to its heap after a burst instead of giving it back. The GOMEMLIMIT above is the setting doing the real work, since the runtime then keeps itself under the soft cap instead of borrowing memory the Pi does not have.

A watchdog covers what I cannot. A two minute timer probes the public URL and reads the tunnel's memory, and restarts the tunnel if two probes fail or if it crosses 250 MB. It has restarted it a few times, mostly during the attack. A five second restart is cheaper than an outage nobody is watching.

The collector

Everything on the page comes from one Python file with no dependencies outside the standard library. It reads /proc and /sys every 10 seconds.

def meminfo():
    out = {}
    for line in rfile("/proc/meminfo").splitlines():
        key, _, rest = line.partition(":")
        out[key] = int(rest.split()[0])
    return out

The JSON goes into /dev/shm, which is RAM, because a file every 10 seconds is over 3 million writes a year and the SD card is the first part of a Pi to fail. The counters are the only thing that touches the card, flushed once a minute with a .bak beside them, and every write goes through os.replace so a reader never sees a half-written file.

The bug worth reading this post for: The collector used to empty the access log once it passed a size cap. Caddy holds that file open and keeps its own position in it, so the next write landed past the new end – a sparse file, enormous in size and nearly empty in content, over the cap again on the next tick, emptied again ten seconds later, forever. Visitors read 1 while the site was fast, the CPU was idle and every service reported active. But now, Caddy rotates the log itself, and the collector only reads it.

The counters: Page views come from the page's own /hit request, and readers are counted per device – an open tab sends a random id it keeps in localStorage on the JSON polls it already makes, so two devices on one WiFi count as two. What reaches the collector is a salted hash, held in memory for three minutes, with an address as the fallback for a browser that keeps no storage. And nothing is written to disk.

Response times and the speed test: Response times come from the access log. The speed test runs four times a day against Cloudflare's edge, since Ookla's own CLI does not work here, so the script uses curl with a browser user agent.

A weak power supply: The collector also reads vcgencmd get_throttled for undervoltage and throttling flags, so a weak charger shows up on the page.

The live page itself

Four files with no framework and no build step. index.html, style.css, app.js and a one line beacon.js that reports the page load come to about 14 KB gzipped in total.

The icons are one inline SVG sprite with 26 symbols, so a page with this many small labels still makes no extra requests. By the way, I printed the numbers in full with separators, so a visitor count reads 1,247 rather than 1.2k.

There are no cookies and no third-party requests, and a default-src 'self' policy keeps it that way. The one identifier anywhere is the random device id above, and it never leaves the browser except as a salted hash in memory. For my other sites I use the analytics setup I run on a VPS, and this page needs none of that.

The WiFi link, measured

The Pi is a client on my network rather than a server, so the WiFi link is the slowest part of the setup.

The link runs on 5 GHz, channel 36, at a reported 270 Mbit/s, but the real throughput measures around 43 Mbps against Cloudflare's edge.
Upload matters more than download here, because the visitors pull the page from my house, so the upload side of the line is what everyone shares.
Power save can add latency, and NetworkManager reports it as default on this setup, and it is the first setting I would check if SSH felt sluggish.

What it costs to run

Between 3-5 W of electricity.
Around 250 MB of the 906 MB of RAM the OS can see, with the web server, the collector and the tunnel running.
Under 2% CPU while idle, and about a millisecond for Caddy to hand over the page at the median.
43 Mbps of a 200 Mbps fiber line, which is the WiFi link rather than the board.

By the way, could a Zero 2 W do the same job?

What I learned

Memory is what fills first: Caddy and cloudflared both kept growing under load, on a board with 906 MB. The caps are what stop that from ending in an outage.
Caching made the biggest difference: The page is answered at the edge now, so the Pi stopped handing the same bytes to every visitor, and the size of the audience stopped mattering as much.
The WiFi link is the slowest part: Slower than the board and slower than the line it sits on.
The SD card fails first: Keeping the writes in RAM is the one habit I would keep from this project.
Counting readers without collecting anything was the hard half: Reading /proc is a solved problem.

The page is live at pi.deepakness.com, and it updates every 10 seconds. The Caddyfile, the collector, the units, and the watchdog are on GitHub in a public repo.

Overall, it was a super fun project and I loved every bit of it.

Trying the New DeepSeek Harness

2026-08-16T12:48:37Z

After building such great Pro and Flash models, DeepSeek has decided to step into the harness game as well. Their harness is based on this philosophy of "everything is a plugin", much like the Pi coding agent. I have been using Pi with DeepSeek models for months now, so I was curious to see DeepSeek's own take on the idea.

All tech news and influencers are talking about the new DeepSeek harness, so I had to give it a try. And my experience so far is pretty good to be honest. In this post, I will explain how I installed and set up the harness for myself and what I liked and disliked about it.

What is the DeepSeek Harness?

The DeepSeek Harness or dsh is an open-source agent harness from DeepSeek AI, and that tagline is not just marketing – every part of the product, from the model adapter to the session log to the agent loop itself, is a plugin. It runs on Cordis, so there is no core to patch. You swap a part by mounting another plugin beside it.

The agent can read and edit workspace files, run commands, delegate work to subagents, and keep a plan as it goes.

It is currently in developer preview, and the team is upfront about it in the repo README. It ships as a Web UI at http://127.0.0.1:3080, but that is just one way to use it. There is also a headless mode and a Python SDK for programmatic use, though I did not use them this time.

Installing the DeepSeek Harness

As mentioned on their GitHub repo page, using the npx @deepseek-ai/dsh web command in the terminal is the best way to quickly install and use the harness. But it didn't work for me and threw the following errors.

I then quickly cloned the repo and ran it from the source with the following commands.

git clone https://github.com/deepseek-ai/deepseek-harness.git
cd deepseek-harness
pnpm install
pnpm run build
pnpm dsh web

It's straightforward, and the process takes just over a minute. You get this http://127.0.0.1:3080 URL in the terminal that I opened in the browser. It showed me an "internal testing warning" popup and then asked me to provide the official DeepSeek API key or configure later, as you see.

Setting up a provider

My first impression was that this only works with the official DeepSeek provider, but it works with almost all major providers, and you can add custom ones for any OpenAI-compatible endpoint. Everything lives under Settings > Models.

I added my OpenCode Go API key as you see above, and everything was set to start using OpenCode models inside the harness.

I already use DeepSeek v4 Pro and Flash through my OpenCode Go subscription inside Pi, so the harness now runs the same models with the same thinking levels. The key itself lands in ~/.dsh/.credentials.yaml, while the settings file keeps only a reference to it – the UI never shows the secret back. My ~/.dsh/settings.yaml looks like this.

llm-pi-ai:
  providers:
    opencode-go:
      apiKeyEnv: OPENCODE_GO_API_KEY
agent-default-model:
  provider: opencode-go
  model: deepseek-v4-pro
  reasoningEffort: max

The llm-pi-ai key at the top is a fun detail. The generic provider adapter is built on pi-ai, the model-provider library from the same team behind Pi. So the harness and my favorite terminal agent share more than just the plugin philosophy.

Model changes apply on the next request without restarting the server.

Using the DeepSeek Harness

After I added a local folder (they call it a workspace), honestly, it felt like I'm using the Codex app or ChatGPT web interface. All sessions are on the left side, and you can easily switch among them across different projects.

I really liked the UI and UX.

The first real task I gave it was a deep read-only audit of this very website's repo. I asked it to go through every single line of code, from all perspectives, and give me a brief report. It read my AGENTS.md file first, so all my site rules were in the conversation. Then it split the entire audit into six parallel subagents. One took scripts/, another _data/, one went through all 161 blog posts, another all 491 raw notes, and the rest took templates, CSS, and the top-level content pages.

And here is the part I really liked. Each subagent got its own session, and the dropdown at the top showed me exactly how many were working and the progress on each of them.

Apart from the subagents, I also loved the live stats at the bottom – tok/sec, cache hit rate, tool calls, turns, steps. None of it is necessary, but it makes the whole session feel transparent.

There is also a Trajectory tab for each session that shows the whole session as a timeline – every turn, step, tool call, and nested sub-tool call, each with its token usage and how long it took. Clicking a request opens its input, output, and timing details. It is the most transparent agent UI I have used.

It also felt safe. Everything ran inside the workspace, and the UI asked before anything that needed approval.

Session modes

The harness ships with four session modes, and you pick one when you start a session. A session's mode is fixed at creation – you cannot switch it mid-session, so a different mode means starting a new session.

Standard mode is the full coding agent – file editing, shell, file and web search, skills, planning, goals, subagents, and workflows. It is the default, and the mode I have been using for everything so far.
Code mode has all of Standard's capabilities, but the tools are presented through the Code Mode SDK. Instead of one tool call per action, the model writes a single TypeScript program against a generated SDK and runs it in one go – a sequence that would take five round trips becomes one.
Minimal mode is the opposite extreme, just two tools, a persistent bash shell and the str_replace_editor file editor. No search, no skills, no subagents, no planning. The smallest possible coding agent.
Creator mode is for making your own presets. It has all of Standard's capabilities plus a toolset that can inspect the running harness, experiment with plugins, and author presets. You can duplicate any built-in preset and make it yours, or let the agent draft a custom one for you in Creator mode.

The picker lives in the Agent presets section of the UI, and you can set a default mode for new sessions so you do not have to pick every time.

Things I like about the DeepSeek Harness

Everything is a plugin, for real. There is no core to patch, unlike most tools where you get whatever the vendor ships. It feels like Pi's philosophy with a polished GUI on top, and it is fully open source under MIT – no company decides what features I get.
The Web UI is clean. Sessions on the left, workspaces, and a Codex, ChatGPT or Gemini-like feel without giving up local files.
Subagents with live progress. The parallel audit would have taken forever in a single thread. Six agents, one dropdown, and live progress on each one.
Honest stats at the bottom. tok/sec, cache hit rate, tool calls, turns, steps. I wish more tools showed numbers like these.
Any provider you want. I plugged in OpenCode Go and was done. Keys stay in ~/.dsh/ on my machine.
Safe by default. A workspace-only sandbox plus approval prompts before risky operations.

Things I didn't like

The npx install did not work for me and I had to run it from source. Not a big deal, but the "one command" pitch should work.
Starting it is not instant. I have to launch the server from a terminal and then open the localhost URL in the browser before I can start working. It is fine once it is running, but it is more friction than just typing pi in the terminal.
It does not ping you when a task finishes. No sound, no notification – the harness just sits quietly in its browser tab, so for long-running tasks I keep switching back to check whether the agent is done yet.
DeepSeek models are text-only, so pasting an image into the harness does not work. In Pi I use a vision-handoff package that describes images with a separate vision model, and I have not found the equivalent setup in the harness yet.

Final thoughts

DeepSeek Harness is the GUI-shaped plugin agent I did not know I wanted. Pi stays my terminal agent for side projects and experiments, and Grok Build and Claude Code keep their roles in my AI stack – the harness is a strong addition, not a replacement yet.

After Pi and OMP, the plugin-first idea has clearly spread, and now DeepSeek ships their own take with real polish. I will keep using it for this site's work and update this post as I learn more.

If something breaks, GitHub Discussions and their Discord server are the places to report it.

How I Publish Blog Posts and Notes So Fast

2026-08-03T18:09:05Z

A reader recently sent me a message asking:

"How are you able to publish blog posts and raw notes so fast? What's your setup like, and are you using some background automation or API?"

It's a great question. When people see someone posting quick notes and blog posts regularly, they usually think there's some complex CMS or API running in the background.

The truth is, I don't use any web dashboards or complex APIs. I just have a simple setup with terminal scripts, a few VS Code extensions, and small background automations that remove all friction.

Here's how my setup works and why it's so fast.

1. Two types of content: Blog vs Raw notes

One of the biggest reasons people take so long to publish is mental friction. If every post needs to be a 2,000-word polished essay, you overthink and end up publishing nothing.

To solve this, I split my content into two types:

Blog posts under /blog/: Longer, detailed guides and essays, like my post on setting up OMP
Raw notes under /raw/: Short technical notes, quick fixes, links, or random thoughts

Having a separate section for raw notes changed everything for me. I don't worry about perfect structure or length. If I learn a quick trick or fix a bug, I just drop it in a note and publish immediately.

By the way, I was inspired by Simon Willison's blog a lot, when I migrated my blog from WordPress to 11ty last year.

2. Terminal shortcuts over web dashboards

I don't log into WordPress, Ghost, or any admin panel or CMS to write. Everything lives in plain Markdown files on my computer.

Instead of opening a folder, creating a file, and manually adding dates and tags, I wrote a few small Node.js scripts.

When I want to write a new note, I just open my terminal and run:

pnpm raw my-quick-note

Or for a blog post:

pnpm blog my-new-post

This single command:

Creates the Markdown file in the right folder
Fills in the date, title, and initial tags automatically
Opens the file directly in VS Code

It takes less than a second to get from an idea to a ready-to-type Markdown file.

3. VS Code extensions that speed up writing

I write and edit everything inside VS Code. To keep the writing process smooth and fast, I rely on a few simple extensions as well:

LTeX+ (grammar/spell checking using LanguageTool): Great for basic spelling and grammar checks while typing.
Markdown All in One: Makes writing Markdown much faster with simple keyboard shortcuts, like Cmd+B for bold, Cmd+I for italics, auto-formatting lists, and quick heading shortcuts.
Markdown Table: Takes the headache out of creating and formatting Markdown tables so everything stays neatly aligned automatically.

4. Automation doing the heavy lifting

Once I finish writing, I don't want to spend time optimizing images, making social preview cards, or running multiple Git commands.

I built a simple command pnpm ready that runs automatically before publishing:

Image optimization: It automatically resizes and optimizes all new images so the page loads fast.
OG preview images: It generates custom social share cards automatically. I also wrote about how I built custom OG images earlier.
Asset sync: It uploads images to Cloudflare R2 so they load fast, and the site repository stays lightweight.

And to push the post live, I run just one command:

pnpm raw:push

This runs the checks, optimizes images, uploads them to R2, commits the changes, and pushes to GitHub. Netlify picks it up and deploys the site live in around 30 seconds.

5. The 2-minute workflow

Here's what publishing a quick note looks like from start to finish:

Open terminal and run pnpm raw <title>
Write the note in VS Code
Run pnpm raw:push

That's literally it. From an idea in my head to a live link on the internet, it takes under two minutes.

But yes, publishing blog posts takes much longer than this as they are more thorough.

Why speed matters

If publishing a quick thought takes 15 minutes of logging in, clicking buttons, and formatting layout, you will eventually stop doing it. By building small terminal shortcuts and letting scripts handle the boring parts, publishing becomes as fast and natural as writing a note to yourself.

If you're curious about the full tech stack and infrastructure powering this site, check out the colophon.

Setting Up and Testing OMP (Oh My Pi) Agent

2026-08-12T00:00:00Z

I wrote about setting up Pi a couple of months ago. I still use Pi, but less than before – my daily driver these days is Grok Build, as noted on my AI stack page. I recently discovered OMP (Oh My Pi) – a different terminal coding agent based on Pi – and I have been liking how it works so far. I am still testing it, but one thing I really like is how it lets my model services work together instead of competing.

DeepSeek v4 Flash does the everyday work, and Grok 4.5 handles vision and planning. Nemotron 3 Ultra is my secondary model, waiting in the fallback chain so a rate limit never stops a session.

Here's how it works.

The problem

I use two model services:

DeepSeek v4 Flash – my default driver. Fast, cheap, and it handles most of what I do day to day.
Grok 4.5 (xAI) – handles vision and planning, since DeepSeek is text-only.

The problem was never "which model is best". The real problems were using all of them without manually switching models every few minutes, and keeping long sessions alive when rate limits hit.

Model roles

OMP has a model roles feature where instead of configuring one model, you configure a model for each role in the config file:

Role	What it does
`default`	The main model that does the actual work
`plan`	Used when a task needs planning first
`slow`	The heaviest model, for the hardest problems
`task`	Subagents – the model used when work is delegated to parallel agents
`smol` / `tiny`	Lightweight tasks like titles and commit messages
`vision`	Image analysis
`designer`	UI and design work
`advisor`	A second model that watches every turn and can interrupt with concerns

Each role also takes a thinking level: minimal, low, medium, high, xhigh, or max. So "use DeepSeek for everything, but with different thinking effort" is literally a few lines of config. The complete list of roles lives in the settings documentation under modelRoles.

My current setup

My global config at ~/.omp/agent/config.yml maps roles to models:

modelRoles:
  default: deepseek/deepseek-v4-flash:max
  plan:    xai-oauth/grok-4.5:high
  vision:  xai-oauth/grok-4.5:medium
  tiny:    deepseek/deepseek-v4-flash:high
defaultThinkingLevel: max

DeepSeek v4 Flash is the default because it handles most of my work fast and cheap, with max thinking. Grok 4.5 handles planning and looks at images, since DeepSeek is text-only. And lightweight one-off calls like titles also go to Flash.

I started with separate profile files pinned per project – a shell function that copied a profile from ~/.omp/profiles/ into each project's .omp/config.yml. It worked, but I settled on a single role-based config instead. The roles cover the switching I actually need, and one global config is easier to maintain than a profile per project.

The advisor

OMP also has an advisor role – a second model that reviews each completed turn and can interrupt with a concern if the main model is about to do something wrong. I used exactly that when I started, with a stronger model supervising a cheaper driver.

My current config has it off:

advisor:
  enabled: false
  syncBacklog: "off"
  immuneTurns: 3

It's a single toggle, so it's easy to bring back when I want a second set of eyes on a session.

Approval mode

I run everything in yolo mode – all commands and edits are auto-approved, no permission popups. I know most people would hate this, but it works for me for two reasons: I review every diff before committing, and the sessions are easy to redo if something goes wrong. The approval modes are worth reading before you decide.

Approval policy is a global setting – role configs only set models, so safety policy stays the same everywhere.

Fallback chains

Rate limits come with the models I use most, and I have hit them during long sessions – the session would have stopped dead if OMP didn't handle it. So Nemotron 3 Ultra sits in a fallback chain as my secondary model, ready when the primary fails:

retry:
  fallbackChains:
    default:
      - opencode-zen/nemotron-3-ultra-free

When the active model fails or exhausts its limits, OMP automatically retries and then moves down the chain instead of stopping. The session keeps going, and once the primary model is available again, it switches back. I have had long sessions survive rate limits this way without touching anything.

Final thoughts

OMP is still in its testing phase for me. Pi still has its place, mainly for side projects, and I have been using it regularly. So far, here is what I like about how OMP works:

DeepSeek v4 Flash as the default driver with max thinking
Grok 4.5 for vision and planning
Nemotron 3 Ultra as the secondary model in the fallback chain
Fallback chains so a rate limit never stops a session
YOLO approvals, with diff review before commits

The best part is that this is all config files – no product decision locked me in. If DeepSeek, Codex, or any other provider releases something better, I can switch to it with one line in the config. If I want a project to behave differently, I can change a role or pin a different config.

I will keep updating this post as the setup changes.

I Bought a $100 Laptop – Mid 2014 MacBook Pro

2026-06-21T00:49:52Z

Two days ago, I was at home and ordered food online. I went to pre-approve the delivery on the apartment's app, and saw an ad selling an old MacBook Pro (Retina, 15-inch, Mid 2014, 16 GB RAM, 120 GB SSD) for only ₹12,000 (~$130) from another resident. I inquired immediately and went there to take a look at it.

The laptop seemed in good condition, I used it for a bit, checked random stuff, and then was ready to buy. I was ready to pay the listed price, but then just asked if they could lower the price to ₹9,000 (~$100) and they agreed immediately. I, then, paid the price and took this 12-year-old laptop home, with its original charger.

When I asked, their main reason for selling was that they weren't able to install newer apps – the laptop was still running macOS Big Sur, the last official update from Apple. For me, before my current MacBook Air M2, I had never used any Apple product, so I was just curious about this decade-old laptop.

By the way, this is how the laptop looks. I absolutely love the backlit Apple logo here.

After getting the laptop, I researched a bit about it and used the OpenCore Legacy Patcher (OCLP) and upgraded to macOS Ventura 13.7.8 and it's running fine so far. I tried installing the Codex app and a few other apps on it and they all work as expected, no lag or slowness at all. Obviously, it's not as powerful as my M2 Air, but it's more than worth the price I paid.

I haven't spent much time on it yet, but it seems like a good machine. It's heavy, but I can keep it open on my desk and use it for scraping or some long-running tasks, so I don't have to keep my main laptop running (Codex /goal, I'm looking at you).

I even tried installing Omarchy Linux on an external SSD connected to the laptop, and it works fine as expected. Here's a picture of it booted into the Omarchy OS.

The speakers aren't great, but that's not an issue because that's not what I got it for.

For now, I will keep exploring things I can do with this second laptop.

Let's see how it goes.

Setting Up and Using the Pi Coding Agent

2026-08-14T00:00:00Z

I have been using AI coding tools for a while now. I have used tools like Cursor and OpenAI Codex for main project work, but my current setup is different. Pi paired with DeepSeek is my daily driver, I use Grok Build for some complex tasks, and Claude Code mainly for frontend design work.

But a few months ago, in May, I came across Pi – an open-source terminal coding agent. It has a small core and lets you add features through extensions and packages, instead of packing everything in by default. I liked the idea, so I decided to set it up and see where it fits.

I am still figuring out the right balance, but Pi has already become my daily driver. In this post, I'll share how I installed it, what my setup looks like, and my honest experience so far.

What is Pi?

Pi is an open-source terminal coding agent created by Mario Zechner. It works in your terminal and gives the AI model four tools by default – read, write, edit, and bash – to work with your codebase.

There is no built-in plan mode, no sub-agents, no MCP, and no permission popups. Instead, you can add these things through extensions, skills, and packages. This keeps the core small and lets you build exactly the setup you want.

Pi works with many AI providers – Anthropic, OpenAI, DeepSeek, Google Gemini, Groq, xAI, OpenRouter, Kimi, and basically almost every other provider as well. You can use an API key or log in with an existing subscription.

How I use Pi alongside other tools

Right now, I use different tools for different kinds of work:

Pi with DeepSeek models as my daily driver for most of my work
Grok Build for some complex tasks
Claude Code mainly for frontend design and UI work

I have also used Cursor and OpenAI Codex for main project work. They are still part of my AI coding journey, even though they are not the tools I currently use most.

Pi feels right as my daily driver because it's fast, lightweight, and I can use cheaper models without burning through expensive subscriptions.

One example: I recently used Pi with the DeepSeek v4 Flash model to scrape 285K URLs from a website. It ran for about 1.5 hours and cost me just $1 through the official DeepSeek API. I used the pi-codex-goal extension to track the long-running task and it worked without issues. You can read more about this on X.

Installing Pi

Installation is one command:

curl -fsSL https://pi.dev/install.sh | sh

Once installed, start it by typing pi in your terminal. But first, you need to set up a provider.

Setting up OpenCode Go as the provider

Pi has a built-in /login command that makes setting up any provider easy. I am subscribed to OpenCode Go, so I logged in with my subscription instead of an API key. Here is what I did:

Opened Pi by typing pi in the terminal
Typed /login and chose OpenCode Go
Logged in with my existing subscription

That's it. After logging in, use /model to pick your model – I chose deepseek-v4-pro with max thinking.

Earlier I used DeepSeek through the official DeepSeek API on a pay-as-you-go basis, and I still keep that key around as a backup. OpenCode Go now covers most of my usage.

I default to max thinking because I want the model to think deeply before making changes. For lighter tasks like the URL scraping, I switch to the faster and even cheaper deepseek-v4-flash model.

You can open the model picker with Ctrl+L, cycle through your scoped models with Ctrl+P, and change the thinking level with Shift+Tab.

I also use Grok 4.6 for more complex tasks – more on that in the model lineup below.

My model lineup

I have several models enabled and switch between them depending on the task:

Model	What I use it for
DeepSeek v4 Pro	Default for most of my work – runs through my OpenCode Go subscription
DeepSeek v4 Flash	Lighter, repetitive tasks like scraping or bulk file operations – fast and cheap
Grok 4.6	More complex tasks – runs through my SuperGrok plan
GPT-5.6 Luna	Vision model for pi-vision-handoff – runs through the Codex free plan or OpenCode Go

Switching is instant – Ctrl+L opens the model selector, and Ctrl+P cycles through scoped models.

The interface and my custom footer

When you open Pi, the interface is clean. The editor is at the bottom, the conversation in the middle, and the footer shows your working directory, git branch, current model, thinking level, and context window usage.

One thing I customized early on was the footer. The default footer shows more information than I need. So I asked Pi itself to build me a custom minimal footer. I described what I wanted – current folder, git branch with a dirty marker, model name, thinking level, an optional goal slot, and a compact context bar – and it wrote the TypeScript extension for me.

The extension lives at ~/.pi/agent/extensions/minimal-footer.ts and Pi loads it automatically on every startup. I have also put the code in a gist – just drop it into the extensions folder and restart Pi. It was a small change but it made the experience feel personal. I also learned a bit about how Pi extensions work in the process.

I recently added another small extension called Whimsical working messages, based on Armin Ronacher's original whimsical extension. I customized it with more colors, decorative symbols, and rotating status phrases that change every two seconds while Pi is thinking. The extension lives at ~/.pi/agent/extensions/whimsical.ts and can be installed by copying my gist into the extensions folder.

Packages I installed

Pi packages are npm or git packages that bundle extensions, skills, prompts, and themes. You install them with pi install. Here are the ones I use:

1. pi-web-access

This package gives Pi the ability to search the web, fetch page content, extract YouTube video transcripts, and explore GitHub repos. You can find it at pi.dev/packages/pi-web-access.

pi install npm:pi-web-access

It works out of the box with Exa search (no API key needed), and you can optionally add API keys for Perplexity, Exa, or Gemini for more control. I configured it to use Exa as the default search provider by creating a ~/.pi/web-search.json file:

{
  "provider": "exa",
  "allowBrowserCookies": false,
  "summaryModel": "opencode-go/deepseek-v4-flash",
  "workflow": "none",
  "curatorTimeoutSeconds": 20
}

With this package, Pi can search the web, read documentation, understand YouTube videos, and clone and explore GitHub repositories – all without leaving the terminal.

2. pi-vision-handoff

DeepSeek cannot look at images – it has no vision capabilities. I use the pi-vision-handoff package, which describes images with a vision model and hands the text description back to the non-vision model.

pi install npm:pi-vision-handoff

I have set up GPT-5.6 Luna as my vision model through the Codex free plan, which has surprisingly generous free limits. I can also run it through my OpenCode Go subscription. Whenever I paste an image into Pi, Luna describes it, and then DeepSeek uses that description to finish the task. It works well for the occasional screenshot or design reference I throw at it.

The handoff approach is provider-agnostic, so I can pick any vision-capable model from the /vision-handoff picker and every text-only model I use can suddenly see images. Descriptions are cached per image and batched into a single vision call, so repeated screenshots don't get re-analyzed.

I have also tried pi-codex-goal for goal tracking, pi-agent-browser-native for browser tasks inside the terminal, and pi-cursor-sdk for using my Cursor subscription inside Pi, but I don't use them anymore. I wrote about the Cursor setup in my raw notes and the long-running /goal tasks as well.

Project instructions with AGENTS.md and APPEND_SYSTEM.md

Pi has two ways to give the model instructions: AGENTS.md for project-specific context, and APPEND_SYSTEM.md for global behavioral rules.

AGENTS.md (project context)

Pi loads AGENTS.md files at startup and injects them into the system prompt. There are three discovery locations – a global one at ~/.pi/agent/AGENTS.md, then parent directories walking up, and finally the current directory – and they're all concatenated together.

I keep my global AGENTS.md minimal. It only describes what stack I typically work with:

# Global Pi Instructions

- Projects commonly use Laravel (PHP/Inertia/React), Next.js
  (TypeScript/Tailwind), or Astro. Check the project-root AGENTS.md for
  stack-specific rules – if none exists, ask.

The "if none exists, ask" part is important. When I'm working in a plain HTML/CSS/JS folder or some other stack, the agent doesn't force a framework on me – it just asks.

Most of my projects also have their own AGENTS.md with framework-specific rules, but I rarely write them by hand. They're generated by the framework tooling (like Laravel Boost) with the exact package versions and conventions for that project.

APPEND_SYSTEM.md (global behavioral rules)

AGENTS.md is for project context, but some rules apply across every project regardless of stack. That's where APPEND_SYSTEM.md comes in. It lives at ~/.pi/agent/APPEND_SYSTEM.md and gets appended directly to the system prompt – which means these rules carry higher authority than AGENTS.md instructions.

Here's what I put in mine:

- If the default provider doesn't have vision capabilities, use
  pi-vision-handoff for images.
- Read relevant local files first when the answer is available in the
  codebase. If not, research online via pi-web-access. Before making a
  big change based on online research findings, confirm with me first.
- Explain risky file edits and destructive commands before executing.
- Write simply. Avoid AI-slop language – no flowery adjectives,
  unnecessary adverbs, or overly formal phrasing.
- Use en dashes (–) not em dashes (—).

A few notes on these rules:

The vision handoff rule is now provider-agnostic. I might use DeepSeek, Grok, or another model as my default, so instead of hardcoding a provider name, it checks whether the current model has vision capabilities.
The second rule is more explicit than my earlier version. Instead of just saying "don't search for things you already know", it tells the agent to read local files first, search online only when needed, and confirm before making big changes based on online research.
The en dash rule is a simple mechanical preference that keeps my writing style consistent across all sessions.

Keyboard shortcuts and commands I use

Pi has many shortcuts. Here are the ones I use regularly:

Key	What it does
`Ctrl+L`	Open the model selector
`Ctrl+P`	Cycle through scoped models
`Shift+Tab`	Change thinking level
`Ctrl+C` (twice)	Quit Pi
`Escape`	Cancel or abort the current action
`Enter`	Send as a steering message (interrupts current work)
`Alt+Enter`	Send as a follow-up message (delivered after work finishes)

The difference between Enter and Alt+Enter took some time to get used to. If I want Pi to change direction mid-work, I press Enter. If I just want to add a note for after it finishes, I use Alt+Enter.

And these are the commands I use, often by typing / in the editor:

/model – Switch models without remembering the shortcut
/settings – Change thinking level, theme, and other settings
/resume – Pick up from a previous session
/new – Start a fresh session
/tree – See the full session history and jump to any point
/compact – Summarize old messages to free up context
/session – Show current session info like tokens and cost

The /tree command is especially useful. You can see your entire conversation history like a tree, jump to any branch, and continue from there. It's great when you want to try a different approach without losing what you had before. I got very curious about it after coming across this shared Pi session from Dillon Mulroy. I later wrote down everything I learned from that session in my raw notes.

A few things I learned while using Pi

Long sessions fill up the context window. Pi has automatic compaction that summarizes older messages when you're running out of space. You can also do it manually with /compact. And I love the pi --continue command, that directly opens the last chat in the repo/folder.

Another thing I like is the steering system. While Pi is working (running bash commands, editing files, etc.), you can type a new message and press Enter. This queues a steering message that gets delivered after the current tool finishes. I use this when I notice Pi going in the wrong direction mid-work and want to correct it quickly. Sometimes, instead of a steering message, I also do Option+Enter that sends the message after previous output is completely finished generating.

You can also use many providers inside Pi, including OpenAI, Cursor, OpenRouter, xAI, Claude, and more through their APIs.

Things I like about Pi

After using Pi for a few weeks, here's what stands out:

Simple and fast: The terminal interface is snappy. No Electron, no UI lag.
Customizable: I built the exact footer I wanted, picked the packages I need, and the rest stays minimal.
Works with any provider: I use DeepSeek for most of my work through OpenCode Go, and switching between models and providers is one shortcut away. I also learn a lot when using it – you get closer to how things actually work, unlike more polished tools where everything is hidden.
Session tree is brilliant: Being able to branch conversations and go back to any point is something I miss when using other tools.
Open source (MIT): I like that no company decides what features I get or how much I pay.
Compaction just works: I don't think about context limits. Pi handles it in the background, faster and better than others do.

Final thoughts

I currently use Pi with DeepSeek for most of my work, Grok Build for some complex tasks, and Claude Code mainly for frontend and UI work. I have used Cursor and Codex for main project work, and both remain polished tools that do their jobs well.

But Pi has earned a permanent place as my daily driver. It's fast, it's cheap (especially with DeepSeek through my OpenCode Go subscription), and the combination of Pi + a few well-chosen packages has been solid so far.

Here's what my current setup looks like:

DeepSeek v4 Pro with max thinking (default, via OpenCode Go)
DeepSeek v4 Flash for lighter tasks
Grok 4.6 for more complex tasks via SuperGrok
pi-web-access for web search and content extraction via Exa
pi-vision-handoff to handle images via GPT-5.6 Luna (Codex free plan or OpenCode Go)
APPEND_SYSTEM.md with writing style and behavior rules
A custom minimal footer extension
Whimsical working messages extension with rotating status phrases

That's it. I tried more packages but kept only what I actually use.

If you are comfortable in the terminal and like the idea of a minimal, extensible agent, give Pi a try. Start with the basics and add packages as you feel the need.

I have been using Pi for a few months now and the setup is stable. I uninstalled a few extensions that didn't add enough value. The simpler the setup, the better.

I will keep updating this post as I discover new things about Pi.

Self-hosting FreshRSS on a Raspberry Pi device

2026-03-09T00:18:03Z

I love RSS/Atom and am subscribed to at least 75 feeds via the NetNewsWire app on my macOS laptop. While the app works great, sometimes, I want to read blogs on my phone too and my current setup didn't allow that. I had been thinking of solving this problem for a long time, and finally got the idea and time to build a better reading setup when I learned about FreshRSS and that it can also be self-hosted.

Initially, I was ready to self-host this on a tiny VPS, but then I decided to use the tiny Raspberry Pi 4B with 1GB RAM that I had. Now that the setup is ready and I am already using it, it only consumes <250MB of RAM on the Pi device.

In this post, I will note down the whole installation process and my experience at the end:

1. Installing Docker

Docker made the process of installing and maintaining FreshRSS easier, and it was also the recommended way to install the app.

I, first, connected to my Pi device from my macOS laptop via SSH and then ran the following commands to install and start Docker.

# Refresh package lists
sudo apt update

# Install Docker engine + CLI + Compose
sudo apt install -y docker.io docker-cli docker-compose

# Start Docker now and on boot
sudo systemctl enable --now docker

# Test iif everything is working
docker --version
docker compose version
sudo docker run hello-world

Earlier, my device was using ~100MB of RAM when it had nothing installed, and now it was using ~180-ish MB of RAM.

2. Installing FreshRSS on the Pi

As Docker was ready, I proceeded with installing the FreshRSS app.

First, I created a new folder in the root called freshrss and a few subfolders by running the following command:

# Create a new folder and subfolders
mkdir -p ~/freshrss/data ~/freshrss/extensions

# Go into the newly created folder
cd ~/freshrss

Created the compose.yaml file in the freshrss directory with the following content. I used the nano compose.yaml command to create the file, and then pasted the following:

services:
  freshrss:
    image: freshrss/freshrss:latest
    container_name: freshrss
    restart: unless-stopped
    ports:
      - "127.0.0.1:8080:80"
    environment:
      TZ: Asia/Kolkata
      CRON_MIN: "13,43"
    volumes:
      - ./data:/var/www/FreshRSS/data
      - ./extensions:/var/www/FreshRSS/extensions
    healthcheck:
      test: ["CMD", "cli/health.php"]
      interval: 75s
      timeout: 10s
      retries: 3
      start_period: 60s

You might need to modify the TZ (timezone) value, as per your location. And then started the container:

# Start the docker container
sudo docker compose up -d

# Check status using these commands
sudo docker compose ps

If everything works, exit using ctrl + c.

Now, the app is ready and running at the port 8080, but you can't access it from your different devices yet. From here, you have 2 options:

Use Tailscale on all your devices to access
Expose the app to the internet using Cloudflare Tunnel

From the security and ease-of-setup point of view, the #1 method is the best here. But I also wanted to give access to the feed reader app to my friend, so I went with the #2 option.

I will explain the Cloudflare Tunnel method here.

3. Exposing the app to the public internet

First, I needed to install cloudflared on my Pi, so I ran the following commands one by one:

sudo mkdir -p --mode=0755 /usr/share/keyrings
curl -fsSL https://pkg.cloudflare.com/cloudflare-main.gpg | sudo tee /usr/share/keyrings/cloudflare-main.gpg >/dev/null

echo 'deb [signed-by=/usr/share/keyrings/cloudflare-main.gpg] https://pkg.cloudflare.com/cloudflared any main' | \
  sudo tee /etc/apt/sources.list.d/cloudflared.list

sudo apt update
sudo apt install -y cloudflared

I also had to sign up to my Cloudflare account, go to Networking > Tunnels section, and create a Tunnel. Just gave the tunnel a name, and it gave me a command like below that I ran on the Pi:

# Connect to the Cloudflare dashboard
sudo cloudflared service install a_very_long_string_here

# Keep the tunnel running
sudo systemctl enable --now cloudflared

After this I added a destination subdomain, and then added http://localhost:8080 as the service URL, and the app was live.

I opened the destination subdomain I set up in the browser. A FreshRSS installation checklist was shown, and then it asked me to sign up for the admin account. I was in. I tried adding an RSS feed for testing, and it was working.

4. Importing my reading list and final look

I maintain this blogroll page on my website, so I added these feeds to the app. And then I also imported a .opml file shared by Andrej Karpathy earlier, it contained 90+ RSS/Atom feeds of most popular blogs on HackerNews.

I probably don't need all these, but as I spend more time reading, I will slowly keep unsubscribing to the feeds where the content is not relevant to me.

Apart from this, I also did a bit of customizations from the settings, and below is the final look for the reader. The sidebar can be toggled off, so the overall look is cleaner.

Initially, it required getting used to the UI as I have only used NetNewsWire previously and that is simpler to use. But now I like this as well, and have already been using it for a few days.

How the Raspberry Pi 4B is performing

The Pi device is performing surprisingly well. Currently, my friend and I are both using the self-hosted RSS reader, and it doesn't even lag or slow down, even for a bit. It still uses less than 250 MB of RAM, sometimes even less than 200 MB, as you see below:

I am not on an extremely fast but on a 200 Mbps fiber internet connection (I mean, people already moved to Gbps, right?), and loading is still very fast – faster than many managed RSS reader web-apps I have tried.

Also, earlier, I had the Pi device connected to a power adapter via a type-c cable. But then I noticed a USB port on my WiFi router and connected to it, and now it takes the power from the router itself, as you see in the photo above.

What I like about FreshRSS

Some things I love about the open-source FreshRSS app are:

It fetches feed updates on the server-side in the background, so I don't have to wait for 2 minutes for all 90 feeds to get refreshed. When I open the public URL in the browser, it's ready for me to read as new updates are already fetched.
When you mark a post as favorite, it's permanently saved in the SQLite database it uses. Even if the original version is deleted, you still have the locally saved version.

FreshRSS has tons of options that I am still exploring and learning about, and will keep this page updated as I discover more noteworthy things.

How I Sync Mastodon Posts with My 11ty Blog

2026-02-06T16:52:48Z

I don't have a comment system on my blog, so I started adding this comment via email almost a year ago, and received a lot of heartwarming replies through that option. But not everyone wants to email you, so I recently also started adding this "Comment on Mastodon" feature below my blog posts (along with webmentions).

Typically, here's the process that I would follow:

Publish a blog post
Share it on Mastodon, and
Add Mastodon post link in Markdown frontmatter

When you add the mastodon YAML frontmatter in a post, the "Comment on Mastodon" option automatically starts showing below the post. Here's what the frontmatter looks like:

---
date: 2025-01-01
title: "title"
description: "description"
tags:
- tag-one
---

But... it's a tedious process to manually do it each time, isn't it?

I wanted something semi-automated, and I have finally put together a workflow that works for me.

I publish a blog post.
It's automatically published to Mastodon, Threads, and Bluesky via n8n by using Typefully API (see how it's done).
Run a script to auto-fetch and find your Mastodon posts with your blog URLs, and update the frontmatter.

I already use Typefully to schedule my posts on social media, so it's not an additional purchase for me. But you can automate publishing to Mastodon directly via their API.

I am going to paste the entire script that I use for this, you can save it inside, say, /scripts/mastodon.js file.

import fs from 'fs';
import path from 'path';
import { fileURLToPath } from 'url';

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
const ROOT_DIR = path.resolve(__dirname, '..');
const CONTENT_DIR = path.join(ROOT_DIR, 'content');

const MASTODON_INSTANCE = 'https://mastodon.social';
const MASTODON_USERNAME = 'deepakness';
const BLOG_DOMAIN = 'deepakness.com';

const DRY_RUN = process.argv.includes('--dry-run');
const FORCE = process.argv.includes('--force');

// Fetch account ID from username
async function fetchAccountId() {
  const url = `${MASTODON_INSTANCE}/api/v1/accounts/lookup?acct=${MASTODON_USERNAME}`;
  const response = await fetch(url);
  if (!response.ok) {
    throw new Error(`Failed to fetch account: ${response.status}`);
  }
  const account = await response.json();
  return account.id;
}

// Fetch all statuses with pagination
async function fetchAllStatuses(accountId) {
  const statuses = [];
  let maxId = null;
  let page = 1;

  while (true) {
    const url = new URL(`${MASTODON_INSTANCE}/api/v1/accounts/${accountId}/statuses`);
    url.searchParams.set('limit', '40');
    url.searchParams.set('exclude_reblogs', 'true');
    if (maxId) {
      url.searchParams.set('max_id', maxId);
    }

    console.log(`Fetching page ${page}...`);
    const response = await fetch(url);
    if (!response.ok) {
      throw new Error(`Failed to fetch statuses: ${response.status}`);
    }

    const batch = await response.json();
    if (batch.length === 0) break;

    statuses.push(...batch);
    maxId = batch[batch.length - 1].id;
    page++;

    // Small delay to be nice to the API
    await new Promise(resolve => setTimeout(resolve, 100));
  }

  return statuses;
}

// Extract links from HTML content using regex
function extractLinksFromHtml(html) {
  const links = [];
  const regex = /href="([^"]+)"/g;
  let match;
  while ((match = regex.exec(html)) !== null) {
    links.push(match[1]);
  }
  return links;
}

// Parse deepakness.com URL and extract type (blog/raw) and slug
function parseDeepakNessUrl(url) {
  try {
    const parsed = new URL(url);
    if (parsed.hostname !== BLOG_DOMAIN && parsed.hostname !== `www.${BLOG_DOMAIN}`) {
      return null;
    }

    // Match /blog/slug or /raw/slug
    const match = parsed.pathname.match(/^\/(blog|raw)\/([^/]+)\/?$/);
    if (match) {
      return { type: match[1], slug: match[2] };
    }
    return null;
  } catch {
    return null;
  }
}

// Find markdown file for a given type and slug
function findMarkdownFile(type, slug) {
  const possiblePaths = [
    path.join(CONTENT_DIR, type, slug, 'index.md'),
    path.join(CONTENT_DIR, type, `${slug}.md`),
  ];

  for (const filePath of possiblePaths) {
    if (fs.existsSync(filePath)) {
      return filePath;
    }
  }
  return null;
}

// Check if frontmatter already has mastodon field
function hasMastodonField(content) {
  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
  if (!frontmatterMatch) return false;
  return /^mastodon:/m.test(frontmatterMatch[1]);
}

// Insert mastodon field into frontmatter
function insertMastodonField(content, mastodonUrl) {
  // Insert after the opening ---
  return content.replace(/^---\n/, `---\nmastodon: "${mastodonUrl}"\n`);
}

// Scan content directories and find files (optionally only those missing mastodon field)
function findContentFiles(onlyMissing = true) {
  const files = [];
  const contentTypes = ['blog', 'raw'];

  for (const type of contentTypes) {
    const typeDir = path.join(CONTENT_DIR, type);
    if (!fs.existsSync(typeDir)) continue;

    const entries = fs.readdirSync(typeDir, { withFileTypes: true });
    for (const entry of entries) {
      let filePath;
      if (entry.isDirectory()) {
        filePath = path.join(typeDir, entry.name, 'index.md');
      } else if (entry.name.endsWith('.md')) {
        filePath = path.join(typeDir, entry.name);
      } else {
        continue;
      }

      if (!fs.existsSync(filePath)) continue;

      const content = fs.readFileSync(filePath, 'utf-8');
      const hasMastodon = hasMastodonField(content);

      if (!onlyMissing || !hasMastodon) {
        const slug = entry.isDirectory() ? entry.name : entry.name.replace('.md', '');
        files.push({ type, slug, filePath, hasMastodon });
      }
    }
  }

  return files;
}

// Main function
async function main() {
  console.log('\n🐘 Syncing Mastodon links to markdown files...\n');
  if (DRY_RUN) {
    console.log('🔍 DRY RUN MODE - No files will be modified\n');
  }
  if (FORCE) {
    console.log('🔄 FORCE MODE - Will overwrite existing mastodon fields\n');
  }

  // First, check which files need updating
  console.log('Scanning content files...');
  const filesToUpdate = findContentFiles(!FORCE);
  const label = FORCE ? 'files to check' : 'files missing mastodon field';
  console.log(`Found ${filesToUpdate.length} ${label}\n`);

  if (filesToUpdate.length === 0) {
    console.log('✨ All files already have mastodon field. Nothing to do!\n');
    return;
  }

  // Create a set for quick lookup
  const updateSet = new Set(filesToUpdate.map(f => `${f.type}/${f.slug}`));

  // Fetch account ID
  console.log(`Looking up account @${MASTODON_USERNAME}...`);
  const accountId = await fetchAccountId();
  console.log(`Found account ID: ${accountId}\n`);

  // Fetch all statuses
  console.log('Fetching all statuses...');
  const statuses = await fetchAllStatuses(accountId);
  console.log(`Found ${statuses.length} statuses\n`);

  // Build map of blog URLs to mastodon URLs (earliest status per slug)
  const matchMap = new Map(); // key: "type/slug", value: match object
  for (const status of statuses) {
    if (!status.content) continue;

    const links = extractLinksFromHtml(status.content);
    for (const link of links) {
      const parsed = parseDeepakNessUrl(link);
      if (parsed) {
        const key = `${parsed.type}/${parsed.slug}`;
        // Always overwrite to keep the earliest (last in reverse-chronological order)
        matchMap.set(key, {
          type: parsed.type,
          slug: parsed.slug,
          mastodonUrl: status.url,
          blogUrl: link,
        });
      }
    }
  }

  // Filter to only matches for files that need updating
  const matches = Array.from(matchMap.values()).filter(m => updateSet.has(`${m.type}/${m.slug}`));
  console.log(`Found ${matches.length} Mastodon posts for files needing update\n`);

  // Process matches
  let updated = 0;
  let skipped = 0;

  for (const match of matches) {
    const filePath = findMarkdownFile(match.type, match.slug);
    if (!filePath) continue;

    const relativePath = path.relative(ROOT_DIR, filePath);
    const content = fs.readFileSync(filePath, 'utf-8');

    // Check if file already has this exact mastodon URL (skip if same)
    const existingMatch = content.match(/^mastodon:\s*"([^"]+)"/m);
    if (existingMatch && existingMatch[1] === match.mastodonUrl) {
      console.log(`⏭️  Already correct: ${relativePath}`);
      skipped++;
      continue;
    }

    // Remove existing mastodon field if present (for --force)
    let newContent = content.replace(/^mastodon:\s*"[^"]+"\n/m, '');
    newContent = insertMastodonField(newContent, match.mastodonUrl);

    if (DRY_RUN) {
      console.log(`📝 Would update: ${relativePath}`);
      console.log(`   Mastodon URL: ${match.mastodonUrl}`);
    } else {
      fs.writeFileSync(filePath, newContent);
      console.log(`✅ Updated: ${relativePath}`);
    }
    updated++;
  }

  // Files that had no matching Mastodon post
  const notFound = filesToUpdate.length - updated - skipped;

  console.log(`\n✨ Done!`);
  console.log(`   Updated: ${updated}`);
  if (skipped > 0) {
    console.log(`   Already correct: ${skipped}`);
  }
  console.log(`   No Mastodon post found: ${notFound}\n`);
}

main().catch(error => {
  console.error('❌ Error:', error.message);
  process.exit(1);
});

The above Node.js script uses public Mastodon API endpoints that do not require authentication, so you don't even need an API key. It uses fs, path, url, and fetch libraries which are Node.js built-ins.

When I run the script in my terminal by running either npm run mastodon or node scripts/mastodon.js command in my terminal:

Scans my local markdown files in content/blog/ and content/raw/ folders, identifies which ones are missing a mastodon: field in their YAML frontmatter.
Fetches all posts from the @deepakness Mastodon account via the public API by paginating through all posts I have.
Matches posts to blog entries by scanning each Mastodon post's HTML content for links to deepakness.com/blog/[slug] or deepakness.com/raw/[slug], and then maps those back to the related local markdown files.
Updates the frontmatter of each matched markdown file by inserting a mastodon: "https://mastodon.social/..." field.

The script also has two optional flags:

--dry-run shows what would change without writing anything
--force overwrites existing mastodon: fields instead of skipping files that already have one

Also, when multiple Mastodon posts link to the same blog post, it keeps the earliest one (since posts are fetched in reverse-chronological order, the last match per slug wins).

Most probably, you won't be able to directly use this script as it's specific to how my 11ty blog is structured. But you can give the script to any LLM, provide info on how your static blog is structured, and ask to provide the modified version of the script.

I manually run the script every few days, so you won't see the "Comment on Mastodon" link on new posts right away – but it shows up soon enough.

Dynamic Open Graph Images for My 11ty Blog

2026-02-06T09:18:45Z

Apart from adding webmentions and better handling images, I also recently finished setting up dynamic Open Graph image generation on my 11ty blog, and it is now working for blog posts, raw notes, and standalone pages.

Earlier I was using just one default social image for all pages and posts I had. It worked, but all shared links looked repetitive. So I created a local generation script and connected it into my existing workflow.

In this post, I will show the exact setup I am using.

1. How OG image is selected on my website

I use computed data to decide what image goes into og:image and twitter:image and have this file _data/eleventyComputed.js with the following content:

export default {
  ogImage: (data) => {
    // If the post has a custom image in frontmatter, use that
    if (data.image) {
      return data.image;
    }

    // For blog posts and raw notes, use the co-located og.jpeg
    if (data.page && data.page.url) {
      if (data.page.url.startsWith('/blog/') || data.page.url.startsWith('/raw/')) {
        return `${data.page.url}og.jpeg`;
      }
    }

    // Fall back to default metadata image
    return null;
  }
};

And in my base template, _includes/layouts/base.njk, both Open Graph and Twitter tags read this value:

So the priority is:

image from frontmatter (manual custom image)
Generated co-located og.jpeg for /blog/* and /raw/*
Site default fallback image from metadata

And then the final Open Graph image URL looks like the one in the screenshot above.

2. The generator script I use

I use sharp image library with a Node.js script at scripts/generate-og-images.js. And the script does the following:

Scans content/blog and content/raw
Scans top-level pages in content/
Handles homepage as a special case
Skips items that already have og.png, og.jpeg, or og.jpg
Skips items that already have image in frontmatter
Uses MD5 cache in _data/cache/og-cache.json to skip unchanged items
Outputs 1200x630 JPEG images

It uses Vercel's satori library for layout, @resvg/resvg-js for rendering SVG to PNG, and sharp to produce final JPEG. Here are some useful snippets from the generate-og-images.js script.

const CACHE_FILE = path.join(rootDir, '_data', 'cache', 'og-cache.json');
const BLOG_DIR = path.join(rootDir, 'content', 'blog');
const RAW_DIR = path.join(rootDir, 'content', 'raw');
const PAGES_OG_DIR = path.join(rootDir, 'public', 'img', 'og');

if (item.hasExistingOg || item.hasCustomImage) {
  skipped++;
  continue;
}

if (cache[cacheKey] === item.contentHash && fs.existsSync(outputPath)) {
  cached++;
  continue;
}

const outputPath = item.collection === 'pages'
  ? path.join(PAGES_OG_DIR, `${item.slug}.jpeg`)
  : path.join(item.folderPath, 'og.jpeg');

It's a huge 600-line script, so I didn't paste it all here. But you can click this link to view the entire script.

3. Card design setup

I kept the design clean and consistent:

White background with a subtle grid pattern
Blue accent strip at the top
Large post title and optional description
Footer with profile photo, name, and website label

The fonts are loaded from local files, the same ones that I am using on my website, so final images match the aesthetics of the website. By the way, here's the OG image for this post, the one you're currently reading:

4. Commands and workflow

I just run the following command to generate images:

npm run og

In package.json, my local start flow already includes OG generation:

"start": "npm run optimize-images && npm run og && npx @11ty/eleventy --serve --quiet"

So in day-to-day writing, I can quickly regenerate social cards before publishing, and also optimize images on the go.

And above is the terminal output when I run the script.

5. Useful edge case: manual override

If I set an image in frontmatter, generator skips that post on purpose. That lets me keep dynamic generation as default, and still use a custom OG design for specific posts.

Example:

image: "/blog/vivaldi-browser/og.jpg"

That is the full setup I am using right now.

It keeps social cards consistent without manual design work on every post, and cache makes regeneration fast when nothing changes. I will keep improving the design over time, but this setup already works well for my workflow.

Adding Webmentions to My 11ty Blog

2026-08-07T00:00:00Z

I was thinking about this for a long time but I finally added webmentions to my blog. I had zero knowledge about this from earlier, so I had to do a lot of reading about the webmention protocol to completely understand it. But I did... and it's live on my website. You can check out this post which has received some webmentions via Mastodon by the time of writing this post.

When you talk about webmentions, receiving and sending them are two different things. And it becomes a little tricky to implement this on a static website like mine, which is built using 11ty static site generator.

In this post, I will explain my process of how I implemented both the receiving and sending of webmentions. Let's get to it.

1. Receive incoming webmentions

When other people link to your website from their blogs or interact with your blog posts on Mastodon or Fediverse, they send you webmentions that you need to receive to show on your website.

Using the webmention.io service

To receive, I used webmention.io, created by Aaron Parecki, that automatically scans for incoming webmentions and lets you access them via an API. When you sign up for it, it gives you a username, and you need to add the following <link> tags to your HTML. It looks like this on my blog:

<link rel="webmention" href="https://webmention.io/deepakness.com/webmention">
<link rel="pingback" href="https://webmention.io/deepakness.com/xmlrpc">

And after you add this, the webmention.io service starts collecting webmentions on your behalf. You can pull these and show them on your website via their API.

From here, you need to get the webmention.io API key token that we will need in the next step.

Showing webmentions on my blog

Each website is built differently so here I will only explain how I built the setup, and provide you with actual code snippets that I am using.

At first, I created a webmentions.js file in my _data folder with the following content:

import "dotenv/config";
import EleventyFetch from "@11ty/eleventy-fetch";

export default async function () {
  const domain = "deepakness.com";
  const token = process.env.WEBMENTION_IO_TOKEN;

  if (!token) {
    console.warn("WEBMENTION_IO_TOKEN is missing – returning empty webmentions.");
    return { children: [] };
  }

  const url =
    `https://webmention.io/api/mentions.jf2?domain=${domain}&token=${token}&per-page=1000`;

  // Always fetch fresh on each build
  const data = await EleventyFetch(url, {
    duration: "6h",
    type: "json",
  });

  return data;
};

I added the API key in the environment variable WEBMENTION_IO_TOKEN on Netlify, as it will be used during the build time.

Then I created a comments.njk file (here are the entire contents of the file, including CSS) in the _includes folder, and used it inside my post template like below:

After this, I also used a service called Bridgy that connects some services that do not explicitly send webmentions, still grabs the webmentions from those platforms, and sends them to webmention.io. I added Bluesky to Bridgy and it will now grab comments and reactions from Bluesky as well, even though it doesn't natively support it.

And it was live. I could see some webmentions collected in my webmention.io dashboard and then those pages on my website were also showing them.

Above is an example of my current design for showing webmentions below posts and notes. I also created a /webmention page that educates people on what this is and how this works on my blog.

The webmention sections on my blog only update when I publish something new and the site gets re-built on Netlify.

2. Send outgoing webmention notifications

I am using this amazing tool webmention.app, created by Remy Sharp, that automates your outgoing webmentions.

There are multiple ways to use the service, as explained in the docs. I am integrating the service with Netlify by using the "deploy notification" feature.

Open your project in Netlify
Go to Project configuration
Scroll down, click on Notifications
Scroll to Deploy notifications under the Emails and webhooks section
Click on Add notification, select HTTP POST request option
In Event to listen for: select Deploy succeeded
Enter below URL in URL to notify field

https://webmention.app/check?token=[your-token]&limit=1&url=[your-feed-url]

Make sure to replace [your-token] with the token that you get from webmention.app, and [your-feed-url] with the RSS/Atom feed of your website. By the way, there are ways to work without a feed URL as well. You need to go through the docs carefully.

Here are some useful resources that I found helpful during my setup:

Using Webmentions in Eleventy, by Max Böck
Webmentions for your Static Site by Rowan Manning
Sending webmentions from a static site by Sophie
Using Web Mentions in a static site (Hugo) by Paul Kinlan

I am new to this thing, and I am sure that the setup will evolve to become even better in the future. I will keep this page updated.

Update (2026-08-07)

I later removed webmentions from this site entirely. The post above is still accurate as a historical write-up of how receiving (webmention.io + Bridgy) and sending (webmention.app) worked while the feature was live.

For why I removed it, see this later note.

Starting a Newsletter using Listmonk

2026-02-04T00:00:00Z

I have been thinking about starting and maintaining an email list for a long time, and today I finally made it live. It wasn't a straightforward process, but it wasn't extremely complicated either. I had to Google a lot and was finally able to set everything up as I wanted.

For the setup, I used Listmonk (self-hosted) for managing the list. I first tried Amazon SES for sending, then switched to SMTP2GO after SES rejected my account (details near the end). That's still what I use today.

But before I start, below is the form if you'd like to subscribe to my list. I have kept it simple to match the aesthetics of my website. The form lives in the site footer on every page, and there's a fuller pitch on the newsletter page.

Now, let's get to it.

What is Listmonk?

Listmonk is a self hosted email newsletter and mailing list tool. It lets you collect subscribers, manage lists, design emails, and send campaigns using your own email provider like Amazon SES, Mailgun, Sendgrid, and Postmark.

You control your data, your server, and how emails are sent, without paying per subscriber. It's great for newsletters, product updates, and simple email automation.

What is Amazon Simple Email Service (SES)?

Amazon SES (Simple Email Service) is a cloud email sending service from AWS. It is used to send emails at scale for things like newsletters, app notifications, and transactional emails.

You connect your app or tool like Listmonk to SES, and SES handles delivery, spam checks, and inbox reliability while charging based on how many emails you send.

Self-hosting Listmonk

I hosted Listmonk on a Hetzner VPS (CX23, costs $3.5/mo) via Dokploy and it took less than 5 minutes. Here are the steps:

Create an account on Hetzner, get verified, and create a new server. Even the cheapest server CX23 would be more than enough.
SSH into the server, and install Dokploy by following the instructions on their official website.
Open Dokploy, create a new project and create a new service by selecting the already available Listmonk option. Add a custom domain and then deploy the service.

If you see an outdated version of Listmonk in the Docker Compose file, change it to the latest version. In my case, it was v5.0.0 in the Docker Compose file, so I changed it to v6.0.0 which is the latest.

After the deployment is successful, visit the domain you added and register a new Listmonk account, and you should now be inside the app.

Getting the Amazon SES details

I didn't even have an AWS account so I was thinking it's going to be a complicated process, but it wasn't. I asked ChatGPT to guide me through the process, and it did. I just kept providing it with screenshots.

Sign up or log in to the AWS account from here: https://aws.amazon.com/ses/
SES asks you to add and verify your email address and sending domain as well. For example, add and verify you@yoursite.com and also your domain yoursite.com.
Keep other options in these sections as the default: Deliverability enhancements, Create your Dedicated IP pool, and Add tenant management. Review everything and click on Get started.
Verify your sending domain by adding a bunch of CNAME, DMARC, and SPF records at your domain registrar (or at Cloudflare if you're using it).
Now, create SMTP credentials and get the SMTP username, SMTP password, and AWS region (you'll need these inside Listmonk).

I will suggest using ChatGPT, Gemini, or any other AI provider to guide you through everything.

Setting up Listmonk

Now, let's get through the process of setting up Listmonk:

1. General settings

First, you need to do some basic settings in the Settings > General tab, as you see in the screenshot here.

Site name: Add the name of your website where you will be showing the subscription form.
Root URL: Add the root URL of where you have hosted Listmonk. Generally, people host at a subdomain of their main domain so the URL will be something like below
- https://list.yoursite.com
Logo URL: This is the logo that is shown at the top of your emails. You can upload the logo to the media library and add the URL here.
Favicon URL: This is shown as the favicon on the public archive pages, if you choose to make your issues public.
Default from Email: Add your email that you want to send from.
Admin notification emails: Add your email where you want to receive the notification when a campaign gets completed, and other admin related things.

2. SMTP settings

You now have to do the SMTP settings and you will need your Amazon SES credentials that you created earlier. See the below screenshot for more info.

Enabled: Should be turned on.
Host: You need to add this, but replace the AWS_REGION here:
- email-smtp.AWS_REGION.amazonaws.com
Port: Use 587 as the SMTP server port.
Auth protocol: Use LOGIN.
Username: Paste the AWS SES username here.
Password: Paste the AWS SES password here.
HELO hostname: Leave it empty.
TLS: Select STARTTLS here.
Name: Name anything you want.

And keep other options as the default. You can see the screenshot above for more info.

You can test the setup by clicking on the Test Connection on the same screen. And if your SES account is not verified yet, you will only be able to send the email to yourself (the one you added in the AWS SES account).

3. Setting up the subscription form

Inside Listmonk, go to the Lists > All lists and rename the default list to the name of your newsletter. This will be seen by the users in the welcome email. You can select between single and double opt-in. I like to have double opt-in because it's good for deliverability and ensures that only serious people join your list.

Once the list is ready, navigate to Lists > Forms and you can either share the subscription form as the URL shown or get the HTML and embed it on your website.

I have embedded the HTML on my website and it looks like this:

<div class="newsletter-form">
  <p>One email every week on AI, tech, and marketing finds I'd tell a friend about.</p>
  <form method="post" action="https://listmonk.yoursite.com/subscription/form" class="listmonk-form">
    <input type="hidden" name="nonce" />
    <input type="hidden" name="l" value="9dcc7bc2" />
    <input type="email" name="email" required placeholder="Your email" />
    <input type="text" name="name" required placeholder="Your name" />
    <input type="submit" value="Subscribe" />
  </form>
  <p class="newsletter-note">No spam, just chaos.</p>
</div>

I have then added some CSS to make it look like how it currently looks in my website's footer. On mobile, form fields appear one above another.

4. Setting up a campaign template

I like sending plaintext emails so I had to create a new campaign template from Campaigns > Templates, but if you're fine with the default campaign template (you can see the preview), there's no need for this step.

Actually, it's not absolutely plaintext because I want to use the HTML's hyperlink feature.

As you can see, it's just basic HTML for adding a hyperlink in Unsubscribe and View in browser links. I could use plaintext as well here, but the links look very ugly in the email.

5. Sending a test campaign

I recommend to subscribe to your own newsletter and then send a test campaign to make sure everything is working as expected. For sending a newsletter issue, go to Campaigns > All campaigns, delete the existing campaigns, and create a new one.

Name: Name it anything, it's internal and not shown to the subscribers.
Subject: The email subject that you want subscribers to receive.
From: From address that you added in Settings earlier and that you want to send the newsletter emails from.
Lists: Select the list or lists of subscribers whom you want to send the emails to.
Messenger: Keep as email.
Format: Select Rich text as the format.
Tags: Optional.
Send later: If you want to schedule, use the Send later option and select date and time to send. Otherwise, keep it turned off.

Now, Save and go to the Content tab, select Rich text as the format, select either the default template or the new template you created previously, and start writing your newsletter.

As you see in the above screenshot, .Subscriber.Name between double curly braces will be replaced by the actual name of the subscriber. You can learn more about template expressions from this page in their docs.

After finishing writing, you can preview how it will look to the user, save changes, and start the campaign by clicking on the Start campaign button at the top.

And seconds later, I received this test email in my Gmail account. It's mostly plaintext and uses HTML for the hyperlinks. I'll probably use HTML for images if I add any.

That's it.

If you're setting Listmonk for yourself and got stuck somewhere, please email me and I would be happy to help.

Update: Feb 4, 2026

Amazon has rejected my application for SES approval without giving any proper explanations, and I received this email from them.

Now, with SES out of the question, I evaluated other SMTP options and have settled with this service called SMTP2GO for now. It offers 1,000 emails per month for free (with a limit of 200/day), and that's enough for me as of now, as I do not have any subscribers yet.

You can see my current Listmonk setup with SMTP2GO in the above screenshot. I tried subscribing to my newsletter from my other email, and it works well for now.

Trying and Migrating to Vivaldi Browser

2026-02-03T00:00:00Z

I have known the Vivaldi browser for years but never actually tried it, until it was recently recommended by Ralf Christian on X. Currently, I am using the Helium browser for the last few months, and it works fine but lacks some features like Widevine DRM, translation, etc.

So... this time I actually decided to try the Vivaldi browser. I'm on macOS currently, so I downloaded the .dmg installation file (~220 MB in filesize) and installed it as you would any other app.

In this post, I will share my experience of using the browser – things I liked and also things I didn't.

1. First impression

After opening the browser for the first time, the onboarding flow was great, and the import from other browsers worked fine as well. But when the actual window opened, it was overwhelming as there were a lot of panels, settings, etc.

It took me almost an hour to tweak small things and the final look was like this:

Here are the things that I liked and didn't like in the first hour of using the browser:

Loved the different themes it provides by default and how customizable everything is.
Settings window was overwhelming as it has lots of options, but it's like this for the good reasons.
Loved the widgets on the home page and used the Date and Privacy Statistics ones.
Break Mode (ctrl + .) is amazing.
Different profiles were an expected feature, but Workspaces are an added benefit.
The inbuilt screenshot and page tiling feature.
Proper support for Chrome extensions, I could easily install one from Chrome webstore.
Vertical tabs, I'm not using it but great to have the feature.
A built-in Pomodoro timer? Amazing.
Support for the Manifest v2 Chrome extensions. I successfully installed this Scraper extension.

2. Customizing as per my needs

I changed the below settings from how the browser ships with the default settings:

I don't like my tabs colors changing for different websites I visit, so I had to turn this off. But it was tricky, as searching "accent" in Settings doesn't show anything and I had to manually find this option under Themes > Editor > Accent from Page.
Removed the speed dials from new tabs, as I like to keep the new tab page clean. Currently, I'm just showing the Date and Privacy Statistics widgets on the Home.
Removed some items from the side panel, like some bookmarked websites, translation widget, some extensions that were shown, etc.
Turned off the Use Tab Zoom feature as it resets the zoom level when you re-open the website, and I wanted to retain the zoom level. I had to Google this one.

I must have changed one or two more settings, but overall this was it.

3. Things I loved

Some features in the Vivaldi browser are amazing and not available in most other browsers I have tried so far.

Secure sync feature

I love a reliable sync feature which is also secure, and Vivaldi has it. It provides an end-to-end encrypted sync feature that I connect multiple devices to and share tabs, bookmarks, settings, history, and so on.

I connected my personal browser profile to the Vivaldi browser on my Android phone, and the sync immediately started working.

Vivaldi for Android

Initially, I didn't know that Vivaldi even has a browser for Android phones as well, but I was amazed when I installed it. It didn't have as many customization options as the desktop one

I only spent like 5 mins customizing and it already looks great on my phone. And the best thing now is, I can easily share tabs between my laptop and my phone by using Send to Your Devices feature.

RSS feed reader

When you visit a blog and it has an RSS feed, you see a small feed icon to the right of the address bar and clicking on it opens a small dialog from where you can save the feed. And new posts will be automatically fetched on a regular interval for you to read.

It works much like a fully functional feed reader app. I currently use an RSS reader app called NetNewsWire, but it's a great feature in the browser.

By the way, there's also the Reader View that helps you read any articles without distractions. This feature is available in most browsers though.

Page Actions

One more crazy feature that I haven't seen in any browser is the Page Actions that lets you tweak any webpage for your advantage. Some cool actions are:

Filter Black and White, Filter Grayscale, and even Filter Sepia
Fonts Monospace to convert the fonts on the webpage to monospace
Transition Removed to remove any kind of transitions

... and much more that you can learn about from their documentation.

Mail and Calendar clients

Vivaldi also has this stunning in-built email and calendar clients that you can connect to your Gmail, iCloud, Outlook, or basically any account that supports IMAP or POP3.

I connected my Google Workspace account just to see how it works, but I won't be using this feature as I prefer directly checking my emails via the web interface. But it's a great feature for people who do prefer an email/calendar client.

Or... maybe I will use this feature after I get more comfortable with the browser.

4. Not so cool things

But like anything else in the world, nothing is perfect. I didn't like a few things in the browser:

Dragging a tab from my laptop screen to my second screen has some bugs. I tried dragging an already playing YouTube tab and then the tab was lost – it kept playing in the background but was not visible on either the first or second screen. I had to restart my browser to fix this issue.
Import feature doesn't work for different Chrome browser profiles. I tried importing my main profile and it worked, but I couldn't find a way to import other Chrome profiles. But it's not a deal-breaker, at least for me.

I have completely migrated to the Vivaldi browser and have set it up as my default browser on both my laptop and my phone. It's been only a few hours since I installed it, but I am loving it so far.

I will keep this page updated, if I learn something new about the browser.

Update: Jan 31, 2026

I turned off the drag-n-drop tab tiling feature by disabling the Enable Drag and Drop Tiling option under Settings > Tabs. It was buggy when I tried dragging away a tab into a new window or on my second screen (the same issue that I didn't like above).

It's working fine after turning this off, and I can still tile tabs by clicking on the Page Tiling option in the bottom panel.

Update: Feb 01, 2026

I modified the below options from the Settings:

Enabled Show Full Address from Settings > Address Bar > Address Field Options, as I like seeing the full URLs at the top.
Disabled Display Downloads Automatically from Settings > Downloads, as it was automatically opening the left side panel whenever I downloaded something.
Disabled Prioritize Bookmarks from Settings > Address Bar > Address Field Suggestions, as it was always over-prioritizing bookmarks even after opening another website with a similar name multiple times.

Update: Feb 03, 2026

The #1 bug I talked about in the above "not so cool things" section has become really annoying, so I reported it to the Vivaldi team and hopefully they do something about it. I haven't received any response from them yet, but this is the bug I reported.

Currently, I am not dragging tabs out of the current window because this is super buggy. And since dragging windows works fine, I set up a keyboard shortcut cmd + ctrl + n to move tab to a new window. Now, I can immediately detach a tab from a window to a new window and then drag the new window to my second screen easily.

To set this up, go to Settings > Keyboard, expand Tab toggle, and press whatever combination you want in front of Move Tab to New Window option.

To be honest, I am liking the keyboard shortcut method much better than dragging the tab away.

Better Handling Images on My 11ty Blog

2026-01-28T00:00:00Z

Last year I migrated away from WordPress and I am now using 11ty SSG for my blog deepakness.com. While I was mostly happy with everything, I have also occasionally had second thoughts about using 11ty. The main reason was the increasing Netlify build times as my blog grew. A build was taking up to 1 min 23 seconds, and once or twice I even hit the Netlify monthly 300-minute build time limit.

So I had to find a better way for the site, and I had the following two options in my mind:

Ditch 11ty and start using WordPress or something similar
Stay on 11ty and optimize the build time on Netlify

I went with the #2 option as it required much less work than migrating back to WordPress, and started looking into what's causing the build times to increase so much.

And it was the @11ty/eleventy-img plugin that I was using to dynamically optimize and transform images during build time. While it worked great, it wasted so much compute as it ran image transformations during each build. And I tried using netlify-plugin-cache to cache already transformed images, but it didn't properly work because I am co-locating all images in separate blog folders, as you see below:

blog/
└── some-post/
    ├── index.md
    ├── image-1.png
    └── image-2.png

So... what was the solution here?

I removed the @11ty/eleventy-img plugin and decided to locally process all images using the sharp image library, before sending them to Netlify because the build times will be faster then.

This worked as expected, and here's what I am doing with images:

Resize original images to 1600px, compress, and keep them in their original format
Create a .webp version of images (1200px wide), and save with the same filename
Track already optimized images in the _data/cache/image-cache.json file via MD5 hash

And all this happens with the following script I created:

import fs from 'fs';
import path from 'path';
import crypto from 'crypto';
import sharp from 'sharp';
import { fileURLToPath } from 'url';

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
const ROOT_DIR = path.resolve(__dirname, '..');
const BLOG_DIR = path.join(ROOT_DIR, 'content', 'blog');
const CACHE_FILE = path.join(ROOT_DIR, '_data', 'cache', 'image-cache.json');

// Configuration
const CONFIG = {
  webp: { maxWidth: 1200, quality: 80 },
  original: { maxWidth: 1600 },
  extensions: ['.jpg', '.jpeg', '.png'],
};

// Load or create cache
function loadCache() {
  try {
    return JSON.parse(fs.readFileSync(CACHE_FILE, 'utf-8'));
  } catch {
    return {};
  }
}

function saveCache(cache) {
  fs.writeFileSync(CACHE_FILE, JSON.stringify(cache, null, 2));
}

// Calculate file hash
function getFileHash(filePath) {
  const content = fs.readFileSync(filePath);
  return crypto.createHash('md5').update(content).digest('hex');
}

// Find all images in blog folders
function findImages() {
  const images = [];
  
  if (!fs.existsSync(BLOG_DIR)) {
    console.log('Blog directory not found:', BLOG_DIR);
    return images;
  }

  const postDirs = fs.readdirSync(BLOG_DIR, { withFileTypes: true })
    .filter(d => d.isDirectory())
    .map(d => path.join(BLOG_DIR, d.name));

  for (const postDir of postDirs) {
    const files = fs.readdirSync(postDir);
    for (const file of files) {
      const ext = path.extname(file).toLowerCase();
      if (CONFIG.extensions.includes(ext) && !file.endsWith('.webp')) {
        images.push(path.join(postDir, file));
      }
    }
  }

  return images;
}

// Optimize a single image
async function optimizeImage(imagePath, cache) {
  const relativePath = path.relative(ROOT_DIR, imagePath);
  const hash = getFileHash(imagePath);
  
  // Skip if already optimized with same hash
  if (cache[relativePath]?.hash === hash) {
    console.log(`⏭️  Skipping (unchanged): ${relativePath}`);
    return false;
  }

  const dir = path.dirname(imagePath);
  const ext = path.extname(imagePath);
  const basename = path.basename(imagePath, ext);
  const webpPath = path.join(dir, `${basename}.webp`);

  try {
    const image = sharp(imagePath);
    const metadata = await image.metadata();

    // Create WebP version (max 1200px, quality 80)
    let webpPipeline = sharp(imagePath);
    let finalWidth = metadata.width;
    let finalHeight = metadata.height;

    if (metadata.width > CONFIG.webp.maxWidth) {
      const ratio = CONFIG.webp.maxWidth / metadata.width;
      finalWidth = CONFIG.webp.maxWidth;
      finalHeight = Math.round(metadata.height * ratio);
      webpPipeline = webpPipeline.resize(CONFIG.webp.maxWidth);
    }
    await webpPipeline
      .webp({ quality: CONFIG.webp.quality })
      .toFile(webpPath);

    // Optimize original (max 1600px, keep format)
    if (metadata.width > CONFIG.original.maxWidth) {
      const tempPath = imagePath + '.tmp';
      await sharp(imagePath)
        .resize(CONFIG.original.maxWidth)
        .toFile(tempPath);
      fs.renameSync(tempPath, imagePath);
      // Recalculate dimensions after resize
      const newMeta = await sharp(imagePath).metadata();
      finalWidth = newMeta.width;
      finalHeight = newMeta.height;
    }

    // Update cache with dimensions
    cache[relativePath] = {
      hash: getFileHash(imagePath), // Recalculate after optimization
      width: finalWidth,
      height: finalHeight,
      optimizedAt: new Date().toISOString(),
    };

    console.log(`✅ Optimized: ${relativePath} (${finalWidth}x${finalHeight})`);
    return true;
  } catch (error) {
    console.error(`❌ Error optimizing ${relativePath}:`, error.message);
    return false;
  }
}

// Main function
async function main() {
  console.log('\n🖼️  Starting image optimization...\n');
  
  const cache = loadCache();
  const images = findImages();
  
  console.log(`Found ${images.length} images to check\n`);

  let optimized = 0;
  let skipped = 0;

  for (const imagePath of images) {
    const wasOptimized = await optimizeImage(imagePath, cache);
    if (wasOptimized) optimized++;
    else skipped++;
  }

  saveCache(cache);

  console.log(`\n✨ Done! Optimized: ${optimized}, Skipped: ${skipped}\n`);
}

main().catch(console.error);

The script optimizes the original image, creates a WebP version of the image, and updates the _data/cache/image-cache.json file to avoid re-optimization of the image(s). The script also adds the width and height of the images in the JSON cache file to be later used for width and height in the img tags to avoid any cumulative layout shift on the pages.

And after this my Netlify build time was reduced to just 20 seconds, as you see in the screenshot below:

And I use the HTML <picture> tag to show images as you see below.

<picture>
  <source srcset="./image.webp" type="image/webp">
  <img alt="alt text" decoding="async" width="1200" height="630" src="./image.png">
</picture>

The browser first tries to load the .webp version of the image, and if it's not supported then loads the optimized version in the original format (PNG/JPEG). I only link to the original image in my Markdown file as ![alt](./image.png) and the above picture tag with WebP is automatically added in the final HTML via the following code in the eleventy.config.js file:

	// Picture tag transform: wrap <img> with <picture> for WebP + fallback
eleventyConfig.addTransform("pictureTag", function(content, outputPath) {
  // Only apply to blog pages
  if (!outputPath || !outputPath.endsWith(".html") || !outputPath.includes("/blog/")) {
    return content;
  }

  // Load image dimensions cache
  let imageCache = {};
  try {
    const cacheContent = fs.readFileSync('_data/cache/image-cache.json', 'utf-8');
    imageCache = JSON.parse(cacheContent);
  } catch {
    // Cache not found, continue without dimensions
  }

  // Extract blog slug from outputPath (e.g., "_site/blog/better-images/index.html" -> "better-images")
  const blogMatch = outputPath.match(/\/blog\/([^/]+)\//);
  const blogSlug = blogMatch ? blogMatch[1] : null;

  // Match <img> tags with jpg/jpeg/png src
  return content.replace(
    /<img\s+([^>]*?)src=["']([^"']+\.(jpg|jpeg|png))["']([^>]*)>/gi,
    (match, before, src, ext, after) => {
      // Skip if already inside a <picture> tag
      if (match.includes('data-no-picture')) {
        return match;
      }

      // Create WebP source path
      const webpSrc = src.replace(/\.(jpg|jpeg|png)$/i, '.webp');

      // Keep existing attributes, add decoding async if not present
      let attrs = before + after;
      if (!attrs.includes('decoding=')) {
        attrs += ' decoding="async"';
      }

      // Add width/height from cache if available
      // Convert relative src (e.g., "./image.png") to cache key (e.g., "content/blog/slug/image.png")
      if (blogSlug && !attrs.includes('width=')) {
        const imageName = src.replace(/^\.\//, ''); // Remove leading ./
        const cacheKey = `content/blog/${blogSlug}/${imageName}`;
        const cached = imageCache[cacheKey];
        if (cached?.width && cached?.height) {
          attrs += ` width="${cached.width}" height="${cached.height}"`;
        }
      }

    return `<picture>
      <source srcset="${webpSrc}" type="image/webp">
      <img ${attrs.trim()} src="${src}">
    </picture>`;
    }
  );
}

The setup is a bit complicated, but I am very much satisfied with the setup, and will stay with 11ty, for now.

Creating My First WordPress Plugin

2026-01-22T00:00:00Z

I created my very first WordPress plugin called Bulk Classic to Block, and now it's live on the WordPress.org repository. It was a fun process, but definitely wasn't straightforward as it took me almost a month to get the v1.0.0 live.

But I'm ready to explain the entire thing in detail in this blog post, so let's directly get to it.

1. The idea for the plugin

I had a really old WordPress website which was untouched for years and was still using the Classic Editor, and since there were 100s of pages on the site, it wasn't manually possible to convert each page to Blocks. So... I then got this idea of creating such a WordPress plugin which does this in bulk.

Initially, I didn't know if such a thing would even work or not, but I researched a bit and then started working on the plugin. I used Cursor AI and Google's Antigravity for developing this.

2. Initial submission to WordPress.org

I, first, submitted the plugin to WordPress.org on November 29, 2025 and received the following email immediately after that.

And then I heard nothing from them for a few days.

3. Plugin checked by a volunteer

13 days later, on December 8, 2025, I received the below email saying that a volunteer has checked my plugin and has identified some issues that need to be corrected and that I needed to resubmit the updated version.

Mainly, the issues were related to the following 2 things (along with the solutions suggested):

Use wp_enqueue commands
- wp_register_script() and wp_enqueue_script() to add JavaScript code from a file.
- wp_add_inline_script() to add inline JavaScript code to previous declared scripts.
- wp_register_style() and wp_enqueue_style() to add CSS from a file.
- wp_add_inline_style() to add inline CSS to previously declared CSS.
Nonces and User Permissions Needed for Security
- Please add a nonce check to your input calls ($_POST, $_GET, $REQUEST) to prevent unauthorized access.

4. Updated and re-submitted the plugin

I then updated the plugin according to the volunteer's detailed suggestions and re-submitted it for approval on the same day. I also sent them this email, as suggested in the previous email.

And then I waited, expecting more issues to be flagged by the volunteer.

5. The plugin gets approved

To my surprise, today I received this email from WordPress saying that the plugin is now approved. I was happy that now it should be live, but then visiting this URL https://wordpress.org/plugins/bulk-classic-to-block/ showed nothing.

So... I went through the email again, this time reading every line, to discover that now I have to upload the approved code to WordPress Plugin Directory via SVN. This information was sent in another email that you see below.

I started learning about using SVN for WordPress and then got some understanding that it's a version control system, much like Git. Also learned that it can be used via CLI as well as via some GUI clients like TortoiseSVN and SmartSVN, again, much like Git.

6. Uploading the plugin

I decided to use the CLI for using svn (Subversion) because what's even the fun in using this via the GUI. At first, I had to install this on my computer. I was using macOS, so I decided to install svn via Homebrew by running the following command:

brew install subversion

The idea here was to pull the public WordPress.org repo of my plugin in a folder locally, copy the plugin files in the specified folders, and then push everything live. The code files (images) went in the trunk folder and then screenshots and icons went in the assets folder. Below are the svn commands I had to execute:

# Executed at first
svn checkout https://plugins.svn.wordpress.org/bulk-classic-to-block

cd bulk-classic-to-block

# After copying files to `trunk` and `assets` folders as specified above
svn status

svn add trunk/* assets/* --force

svn commit -m "Initial commit of plugin files"

svn copy trunk tags/1.0.0

svn commit -m "Tag version 1.0.0"

If you'd like, here's the entire text copied from my terminal.

deepak@m2air wordpress-org % svn checkout https://plugins.svn.wordpress.org/bulk-classic-to-block
A    bulk-classic-to-block/assets
A    bulk-classic-to-block/tags
A    bulk-classic-to-block/trunk
Checked out revision 3424796.
deepak@m2air wordpress-org % cd bulk-classic-to-block 
deepak@m2air bulk-classic-to-block % ls
assets	tags	trunk
deepak@m2air bulk-classic-to-block % svn status
?       assets/screenshot-1.png
?       assets/screenshot-2.png
?       assets/screenshot-3.png
?       trunk/LICENSE.txt
?       trunk/README.txt
?       trunk/bulk-classic-to-block.php
?       trunk/index.php
?       trunk/js
deepak@m2air bulk-classic-to-block % svn add trunk/* assets/* --force
A         trunk/bulk-classic-to-block.php
A         trunk/index.php
A         trunk/js
A         trunk/js/scripts.js
A         trunk/LICENSE.txt
A         trunk/README.txt
A  (bin)  assets/screenshot-1.png
A  (bin)  assets/screenshot-2.png
A  (bin)  assets/screenshot-3.png
deepak@m2air bulk-classic-to-block % svn status
A       assets/screenshot-1.png
A       assets/screenshot-2.png
A       assets/screenshot-3.png
A       trunk/LICENSE.txt
A       trunk/README.txt
A       trunk/bulk-classic-to-block.php
A       trunk/index.php
A       trunk/js
A       trunk/js/scripts.js
deepak@m2air bulk-classic-to-block % svn commit -m "Initial commit of plugin files"
Authentication realm: <https://plugins.svn.wordpress.org:443> Use your WordPress.org login
Password for 'deepak': ********************************************

Authentication realm: <https://plugins.svn.wordpress.org:443> Use your WordPress.org login
Username: deepakness
Password for 'deepakness': ********************************************

Adding  (bin)  assets/screenshot-1.png
Adding  (bin)  assets/screenshot-2.png
Adding  (bin)  assets/screenshot-3.png
Adding         trunk/LICENSE.txt
Adding         trunk/README.txt
Adding         trunk/bulk-classic-to-block.php
Adding         trunk/index.php
Adding         trunk/js
Adding         trunk/js/scripts.js
Transmitting file data ........done
Committing transaction...
Committed revision 3424811.
deepak@m2air bulk-classic-to-block % svn copy trunk tags/1.0.0
A         tags/1.0.0
deepak@m2air bulk-classic-to-block % svn commit -m "Tag version 1.0.0"
Adding         tags/1.0.0
Adding         tags/1.0.0/LICENSE.txt
Adding         tags/1.0.0/README.txt
Adding         tags/1.0.0/bulk-classic-to-block.php
Adding         tags/1.0.0/index.php
Adding         tags/1.0.0/js
Committing transaction...
Committed revision 3424816.
deepak@m2air bulk-classic-to-block %

And then my WordPress plugin Bulk Classic to Block was live, and I could access it from this URL: https://wordpress.org/plugins/bulk-classic-to-block/

7. Future updates

If I update anything in the plugin files in the future, I might need to run the following commands:

cd ~/bulk-classic-to-block

# copy or edit files
svn add assets/screenshot-4.png
# or edit readme.txt

svn commit -m "Update screenshots and readme"

Above is when I add a screenshot or a minor change without the need to bump the version, but when I have to do a new release then the process will be:

Make changes in files in the /trunk folder
Bump the version number in:
1. Main plugin file
2. readme.txt file
3. Changelog section
Commit /trunk by using the svn commit -m "message" command
Create a new tag (important) by running the following commands:

svn copy trunk tags/1.0.1
svn commit -m "Tag 1.0.1"

Also, some other helpful svn commands can be:

# See what changed
svn status

# See diff
svn diff

# Update local copy
svn update

That's it!

I wrote everything in detail here, because I would definitely need to look back at it in the future when I update the plugin or even when I have to publish a new plugin to WordPress.

Update: 22 Jan, 2026

I made the plugin's GitHub repository open source; you can access it here. Now, you can either download the plugin from GitHub releases or directly install via the official WordPress.org repo.

Will keep adding plugin updates to this page in the future.

Upgrading Self-hosted Umami to v3 on a VPS

2025-11-19T17:24:51Z

I recently wrote about self-hosting Umami Analytics on a small Hetzner VPS using Docker and Caddy.

Since then, Umami shipped v3 and I wanted to upgrade my existing install (v2.19.0) without losing any data. In this post, I am sharing the exact steps I followed on my live server.

If you installed Umami by following my earlier post, this guide should be a direct drop-in upgrade for you.

1. Log in to the VPS

From my local machine (macOS), I first SSHed into the VPS:

ssh root@your_server_ip

The server is running Ubuntu 24.04 with Docker CE, same as before.

After logging in I noticed a pending kernel update and a restart notice, so I rebooted first to avoid surprises in the middle of the upgrade:

reboot

Then I connected again:

ssh root@your_server_ip

2. Confirm the current Umami setup

Once logged in, I checked what files are in the root directory:

ls

Output:

Caddyfile  docker-compose.yml

So I opened the docker-compose.yml to confirm the current setup:

cat docker-compose.yml

The important part looks like this:

This is the same Docker setup I used in the original installation post:

umami container using postgresql-latest image
db container running postgres:15-alpine
caddy in front, handling HTTPS and the domain

To make sure everything was running fine before touching anything, I checked the containers:

docker compose ps

Sample output:

NAME           IMAGE                                            COMMAND                  SERVICE   CREATED       STATUS                 PORTS
root-caddy-1   caddy:latest                                     "caddy run --config …"   caddy     4 weeks ago   Up 2 hours             0.0.0.0:80->80/tcp, ...
root-db-1      postgres:15-alpine                               "docker-entrypoint.s…"   db        4 weeks ago   Up 2 hours (healthy)   5432/tcp
root-umami-1   ghcr.io/umami-software/umami:postgresql-latest   "docker-entrypoint.s…"   umami     4 weeks ago   Up 2 hours (healthy)   3000/tcp

All good here.

3. Create a PostgreSQL backup (do not skip this)

Before changing any image or running migrations, I created a full dump of the Umami database.

Since the db service is using:

POSTGRES_DB=umami
POSTGRES_USER=umami

the backup command is:

docker compose exec db pg_dump -U umami umami > umami-backup-$(date +%F-%H%M).sql

This runs pg_dump inside the db container and saves the file on the host with a timestamp in the name.

Then I double checked that the backup file exists and has some size:

ls -lh umami-backup-*.sql

Output on my server:

-rw-r--r-- 1 root root 8.5M Nov 19 14:48 umami-backup-2025-11-19-1448.sql

8.5 MB looks right for my current traffic.

At this point, even if the migration failed, I can restore the DB using this SQL file. That gives a lot of peace of mind.

4. Update the Docker image to Umami v3.0.1

Next, I edited docker-compose.yml to point to the new v3 image.

I used nano:

nano docker-compose.yml

Inside the file, in the umami service, I changed this line:

image: ghcr.io/umami-software/umami:postgresql-latest

to this:

image: ghcr.io/umami-software/umami:3.0.1

Nothing else needed to change – the DATABASE_URL, DATABASE_TYPE, APP_SECRET, and the db service all stay the same.

After saving and closing nano (Ctrl+X, Y, Enter), I confirmed the change with:

grep -A3 'umami:' docker-compose.yml

Output:

  umami:
    image: ghcr.io/umami-software/umami:3.0.1
    environment:
      DATABASE_URL: postgresql://umami:umami@db:5432/umami

Perfect.

5. Pull the new image

Now that the compose file points to 3.0.1, I pulled the new image:

docker compose pull umami

This downloads the ghcr.io/umami-software/umami:3.0.1 image. My output looked like this (trimmed):

[+] Pulling 18/18
 ✔ umami Pulled                                                                       16.0s 
   ✔ fc2cca81d0de Pull complete                                                        2.4s 
   ✔ ...
   ✔ 14e4cc53c863 Pull complete                                                       14.8s

Once this finished, the image was ready on the server.

6. Recreate the Umami container with v3

With the image pulled, I restarted just the umami service using the new image:

docker compose up -d --force-recreate umami

Output:

[+] Running 2/2
 ✔ Container root-db-1     Healthy                                                     0.8s 
 ✔ Container root-umami-1  Started                                                     1.1s

Note that the db container stays the same, including the data volume. We are only replacing the app container.

7. Watch the logs and wait for migrations

The first start after the image change will run database checks and migrations. To see what is happening in real time, I tailed the logs:

docker compose logs -f umami

The logs showed:

umami-1  | > umami@3.0.1 start-docker /app
umami-1  | > npm-run-all check-db update-tracker start-server
umami-1  | 
umami-1  | > umami@3.0.1 check-db /app
umami-1  | > node scripts/check-db.js
umami-1  | 
umami-1  | ✓ DATABASE_URL is defined.
umami-1  | ✓ Database connection successful.
umami-1  | ✓ Database version check successful.
umami-1  | Prisma schema loaded from prisma/schema.prisma
umami-1  | Datasource "db": PostgreSQL database "umami", schema "public" at "db:5432"
umami-1  | 
umami-1  | 14 migrations found in prisma/migrations
umami-1  | 
umami-1  | Applying migration `14_add_link_and_pixel`
umami-1  | 
umami-1  | The following migration(s) have been applied:
umami-1  |   └─ 14_add_link_and_pixel/
umami-1  |     └─ migration.sql
umami-1  |       
umami-1  | All migrations have been successfully applied.
umami-1  | 
umami-1  | ✓ Database is up to date.
umami-1  | 
umami-1  | > umami@3.0.1 start-server /app
umami-1  | > node server.js
umami-1  | 
umami-1  |    ▲ Next.js 15.5.3
umami-1  |    - Local:        http://localhost:3000
umami-1  |    - Network:      http://0.0.0.0:3000
umami-1  | 
umami-1  |  ✓ Starting...
umami-1  |  ✓ Ready in 485ms

This is exactly what you want to see:

DB connection successful
Migrations applied
Server starting and ready

Once I saw the app was ready, I pressed Ctrl + C to stop tailing the logs.

8. Confirm that Umami v3 is live

With the container running, I opened my Umami domain in the browser (the one I pointed to Caddy in the first post).

The login page loaded as usual. After logging in:

The dashboard still showed all the historical data
The list of websites was intact
New pageviews were being tracked without changing the tracking script

If something looked broken here, I still had my SQL backup file to fall back to, but in my case everything worked on the first try.

9. What to do if something breaks

If the logs show errors, or the app keeps restarting in a loop, here is a quick recovery plan:

Stop the stack:
```
docker compose down
```
Bring only the database back up:
```
docker compose up -d db
```

Restore the backup:

cat umami-backup-YYYY-MM-DD-HHMM.sql | docker compose exec -T db psql -U umami umami

Replace the file name with your backup file name.

Change the image back to the old one in docker-compose.yml:
```
image: ghcr.io/umami-software/umami:postgresql-latest
```
Start Umami again:
```
docker compose up -d umami
```

You should now be back on the old version with the old data.

10. Final notes

That is pretty much all I had to do to upgrade Umami from the postgresql-latest v2 image to 3.0.1:

One SSH session
One pg_dump backup
One image tag change
A pull, an up, and a quick log check

If you are running the same Docker + Caddy setup from my earlier post, you can follow the same steps line by line, just replace the IP and domain with yours.

If you try this upgrade and hit any issues, the logs and the SQL backup will be your best friends – check those first before touching anything else.

Self-hosting Umami Analytics on a VPS

2025-11-19T00:00:00Z

A few days ago, I self-hosted Plausible analytics and many people recommended that I should check Umami analytics as it's lightweight and updates are more frequent.

So here it is... I also self-hosted Umami analytics on a $3.50 Hetzner VPS to see if it actually lives up to the hype. First, I will explain the installation steps and then write about my experience.

Installing Umami on a Hetzner VPS

First, you need to have a Hetzner account where you can create new servers. If you do not have one, create one and then get yourself verified, if required (yes, I had to submit my ID a few years ago).

1. Set up the VPS

Create a new server, even the smallest shared server is enough to host Umami as people discussed that only 500 MB RAM is enough to efficiently run it.

Also, I'm not going to explain how to set up a new server on Hetzner so if you need help with that you can go through this post, as I have explained the process a bit.

And as explained, set up a Docker CE app instead of setting up a blank system as we'll be installing Umami via Docker.

Now, connect to the server via SSH from your terminal by running the ssh root@your_ip_address command, and once connected, update the system by running the following command:

sudo apt update && sudo apt upgrade

And it's ready for the installation.

2. Umami and Caddy setup via Docker

While you can directly follow the official installing with Docker steps, I have a better way of doing it by also using Caddy to set up the custom domain.

For this, you need to create a docker-compose.yml file in the root by running the following nano command.

nano docker-compose.yml

Now, just copy-paste the below YML code in the file, then save and exit by pressing ctrl + x and then y. But replace replace-me-with-a-random-string with a string before pasting; I prefer running below openssl command:

openssl rand -base64 32

And then use the generated string below:

services:
  umami:
    image: ghcr.io/umami-software/umami:postgresql-latest
    environment:
      DATABASE_URL: postgresql://umami:umami@db:5432/umami
      DATABASE_TYPE: postgresql
      APP_SECRET: to4KhI0g8Wzaw1r7+vEknSbU4AM4d6LRJyGzlgO5DZY=
    depends_on:
      db:
        condition: service_healthy
    init: true
    restart: always
    healthcheck:
      test: ["CMD-SHELL", "curl http://localhost:3000/api/heartbeat"]
      interval: 5s
      timeout: 5s
      retries: 5

  db:
    image: postgres:15-alpine
    environment:
      POSTGRES_DB: umami
      POSTGRES_USER: umami
      POSTGRES_PASSWORD: umami
    volumes:
      - umami-db-data:/var/lib/postgresql/data
    restart: always
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}"]
      interval: 5s
      timeout: 5s
      retries: 5

  caddy:
    image: caddy:latest
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
      - "443:443/udp"
    depends_on:
      umami:
        condition: service_started
    volumes:
      - ./Caddyfile:/etc/caddy/Caddyfile:ro
      - caddy_data:/data
      - caddy_config:/config

volumes:
  umami-db-data:
  caddy_data:
  caddy_config:

Now, create a Caddyfile by running the below command and paste the below Caddyfile code, but first replace the your_domain_or_subdomain_here with your domain/subdomain.

nano Caddyfile

For example, I can connect it to umami.deepakness.com. Again, press ctrl + x and then y to save and exit.

your_domain_or_subdomain_here {
  encode zstd gzip

  reverse_proxy {
    to umami:3000
    health_uri /api/heartbeat
    health_interval 10s
    health_timeout 2s
  }

  log {
    output stdout
    format json
  }
}

Also, you will need to add a DNS record at Cloudflare (if you're using it) or at your domain registrar. You need to add an A record with your IP address.

For example, I use Cloudflare and this is how I'd add the A DNS record in there.

3. Start Docker containers

Now, everything is ready, and you can just start the docker container by running the below command. It starts all the containers in the background.

docker compose up -d

And then you can also run the below command (optional) to see live logs from the Caddy container so you can see if it gets the SSL certificate and starts properly.

docker compose logs -f caddy

And your Umami Analytics instance should be live!

You can visit the domain/subdomain, and you should see the login screen. Your default username will be admin, and your password will be umami. But you should immediately change your password after logging in.

And that's it.

You can add your website(s) for tracking and start collecting data as explained in their docs.

My experience with Umami

Actually, I liked Umami a lot, it's better than Plausible in terms of server resource usage. You can see the usage here for both:

Plausible is using 1 GB of RAM:

Umami is using ~500 MB of RAM:

Apart from this, I also liked the Umami dashboard a lot as it shows more tracking data while consuming 50% fewer resources than Plausible. Also, Plausible keeps showing a huge footer like below on all pages which I didn't like, but it's not there in Umami.

Apart from this, I liked the data points being shown in Umami, especially the way sessions and events data is shown.

So... that's it.

This time, I am going with Umami as it seemed more polished to me.

Update: November 19, 2025

I upgraded Umami to v3.0.1 and it was a smooth process. Check out my post on upgrading Umami to v3 for more details. I have explained the process in detail.

Self-hosting Plausible on a Hetzner VPS

2025-10-18T13:19:01Z

Previously, I have always used Google Analytics to track visitors on my website, but this time, I decided to use Plausible analytics on my personal website. And mainly because of the following three reasons:

Plausible is lightweight, so it doesn't affect the website loading speed much
Unlike Google Analytics, Plausible is open-source and privacy-friendly, and
The Plausible dashboard is user-friendly and shows essential data without complexity

Now, let's directly go to the self-hosting part. I will explain each and every step of self-hosting Plausible CE on a Hetzner VPS.

1. Set up a Hetzner VPS

If you don't have a Hetzner account, create one and get yourself verified by submitting an ID proof (I don't know if that's for everyone, but I did have to submit). After logging in, go to console.hetzner.com page, create a Project and then go inside the Project to create a Server.

Click on the big Add Server button, and you will land on the below page. In this case, select the Cost-Optimized x86 (Intel®/AMD) version and then the CX23 server as shown in the screenshot. And this is more than enough to run Plausible, as it only requires 2GB of RAM to run efficiently, and we have 4GB here.

Below are the recommendations for other options on the page:

Location: Leave the location to Helsinki as cheaper servers are available here.
Image: Instead of choosing OS Images, go to the Apps section and choose Docker CE.
Networking: Make sure IPv4 and IPv6 are selected. They should already be selected.
SSH Keys: If you use SSH keys on your computer, I'd recommend using these for easier access later. Maybe look it up online on how to set it up for your OS.
Leave Volumes, Firewalls, Backups, Placement Groups, Labels, and Cloud config as they are. No need to write anything here.
Name: Give your server a recognizable name for future reference. You can always change it later.

Click on the Create and Buy Now button and your server will be ready in a few minutes.

2. Install Plausible on the server

Now, you will have to connect to the server from your local Terminal and then install the Plausible CE on the server. To connect, you need to copy the IPv4 from the server that just got created, and run the following command from your terminal:

ssh root@YOUR_IPv4_ADDRESS

If you have the server connected via SSH, you just have to press Enter again, and it will be connected. Otherwise, you might need to enter the server root password.

If you don't choose the SSH method, you will receive the root password via email.

After your terminal gets connected to the server, you can update the server by running the following command:

sudo apt update && sudo apt upgrade

It should look like below:

After this completes, go to the Plausible community edition GitHub repo and follow the instructions. First, you need to run the following command to clone the repo (but make sure to check the latest command from the repo):

git clone -b v3.0.1 --single-branch https://github.com/plausible/community-edition plausible-ce

Now, go to the plausible-ce folder by running below command:

cd plausible-ce

Create a .env file by running the following command:

touch .env

And then add BASE_URL and SECRET_KEY_BASE by running the following commands:

echo "BASE_URL=https://plausible.example.com" >> .env

echo "SECRET_KEY_BASE=$(openssl rand -base64 48)" >> .env

Make sure to replace BASE_URL with the URL where you want to host Plausible. You will also need to add an A DNS record with your server IP at Cloudflare (if you use Cloudflare) or at your domain registrar.

You can also manually add BASE_URL and SECRET_KEY_BASE by running the nano .env command in the terminal.

Now, run the below commands one by one:

echo "HTTP_PORT=80" >> .env

echo "HTTPS_PORT=443" >> .env

And then run the following command:

cat > compose.override.yml << EOF
services:
  plausible:
    ports:
      - 80:80
      - 443:443
EOF

Finally, it's time to start the services with Docker Compose by running the below command:

docker compose up -d

And you will see something like below in the terminal:

Now, it's time to create a user and add your website for tracking.

I have created a short video for self-hosting Umami, so some steps will be the same when installing Plausible.

3. Start tracking visitors

First, you will need to create a user by visiting the BASE_URL you set earlier, something like https://plausible.example.com and create an account with your credentials.

And when asked, add the domain you want to track, something like deepakness.com, and go to the next step. You can enable optional measurements as shown below, and then Copy the script that's being shown in the box.

Now, go to your website and add the script somewhere between the <head>...</head> tags on your website, as explained in their docs. If you're having difficulties, you can also check this page for different installation options for websites with different tech-stacks.

Lastly, click on the Start collecting data button, and you should be good to go within a few minutes. Once correctly installed, you'll start seeing the data being shown in the dashboard.

And the best thing is, you can track users on multiple websites from the single Plausible dashboard.

While I have provided all the commands here in the post, I recommend checking on the Plausible community edition repo in case something changes.

That's it.

I also self-hosted Umami analytics as it was recommended by a lot of folks. In the post, you can also see a short comparison between the two.

Hope this helps.

Trying and Migrating to the Helium Browser

2026-01-30T00:00:00Z

I was using the Brave browser for a few years now, but was also trying different browsers like Ungoogled Chromium and LibreWolf in the search of something better. Honestly, I didn't know what I was looking for in my web browser, but I just kept trying them.

However, I kept coming back to the Brave browser as it has everything that others lack.

But this time, I have completely migrated to the Helium browser, and for good. The browser was recommended to me by Fardeen on X, and I installed it the next day after I saw multiple people mentioning online.

It's been over a week since I started using the open-source Helium as my default browser now, and I've never been happier using a web browser. In this post, I will be sharing my experience – the good, bad, and everything.

1. Clean and quick

When I first installed it, I didn't see any annoying bloatware at all. It looked very clean and minimal on the very first install, and it didn't even have the background image set on new tabs. Unlike the Brave browser, it doesn't have:

sponsored backgrounds
crypto bloats
unnecessary AI push

Below, take a look at how clean it looks.

And the migration process was quicker than I thought, as I was able to import my Brave browser profiles within seconds, including history, bookmarks, and extensions.

2. Based on Chromium

To be honest, I've always liked Chromium engine more than that of any other browser, and the Helium browser is based on Chromium project itself. It's fast and supports all Chrome browser extensions as well.

In fact, it also supports the Manifest v2 extensions and comes with uBlock Origin preinstalled. And manifest v2 is a big deal for me because I want extensions like uBlock Origin and Scraper to keep working correctly for me.

3. Safe and secure

The Helium browser comes with all the good features of the Brave browser in terms of security and also without the tracking capabilities of the Google Chrome browser.

I also noticed that it doesn't save your addresses, card details, passwords, etc. as these features are completely removed from the browser. And I like this a lot because on Brave or Chrome, I always first turned off these features when getting started.

But it still does have the "Use secure DNS" feature which I absolutely need, as I use Cloudflare's 1.1.1.1 DNS resolver.

4. Cool features

While I don't use extra features a lot, they're good to have, and I like them so far. For example:

!bangs are awesome
Split View is handy sometimes

I also like that it lets me completely customize the top toolbar. By the way, this option appears when you right-click anywhere on the toolbar.

There's one minor inconvenience: the browser can't play DRM-protected content, which means you won't be able to watch Netflix or Amazon Prime in the browser. And it makes sense because Helium doesn't have Widevine DRM, as it costs tens of thousands of dollars to get. But it's not a deal-breaker for me, as I rarely watch DRM content on my computer and even if I sometimes do, I still have Brave installed that I can use.

Apart from this, I'm absolutely loving the browser and sticking with it.

Also, it'd be great if the browser was available for mobile devices as well, but I don't think that's possible as of now.

Update: Oct 8, 2025

I just noticed that the Helium browser also doesn't have a translation feature, so if you're visiting a page that's not in a language you know, you can't translate it. But that's not a big deal for me, I can use some browser extension for that when needed.

Update: Nov 5, 2025

Now, it's been more than a month, and I'm still sticking with the Helium browser. I love how clean it is and how there are no distracting elements in the browser. The browser has received 1-2 updates since the installation, but I didn't notice any major changes – everything works as expected.

The browser is very stable and definitely consumes less RAM and resources than the Chrome and even the Brave browser. In the past one month, I had to open the Brave browser once to translate a webpage (as Helium doesn't support translation), otherwise it's good so far.

Update: Jan 30, 2026

I loved the Helium browser as it was my default browser for almost 4 months, but I have recently migrated to the Vivaldi browser.

macOS App to Show Lid Angle in the Menu Bar

2025-09-11T08:51:46Z

I came across this cool project where Sam was able to access a hidden API from macOS which outputs the current angle of the lid. He built a cool app that accessed the API and showed the angle, as shown in the video here.

I was inspired by the project a lot and decided to build my first macOS app – an app that just shows the current tilt angle of the lid/screen in the menu bar. Here's a quick demo video showing the same.

I also posted about the same on X along with the public GitHub repo that you can clone and run the app via Xcode on your MacBook devices.

To build this, I set up a macOS app project in Xcode and then used OpenAI Codex to build the app for me. It took several iterations and also some manual researching and reading about the hidden LidAngleSensor API and how it can be accessed. And then it finally worked.

I still don't know how to get the final executable file from here, but I am reading about it and should also release the .dmg file that one can use to directly install this with just a click.

I have added some more info about how this works and limitations in the README.md file on GitHub. You can learn some interesting things about the API and the app from there.

Will keep updating the post as I discover more.

Git and GitHub for Vibe Coders

2026-08-06T00:00:00Z

This post is written using AI (unlike my other posts). Sometimes, I revisit some of these git commands and it was meant to be a private note, but then I published it because others might also find this useful.

I've been coding with AI tools like Cursor, Claude Code, and OpenAI Codex for a while now, and let me tell you – it's both amazing and terrifying. One moment you're asking AI to "add user authentication to this app," and the next moment you're staring at 200 lines of generated code wondering if it just broke your entire project.

And this is called vibe coding (coined by Andrej Karpathy) – using AI to generate code based on prompts and vibes rather than writing every line yourself. It's incredibly powerful, but it can also turn your codebase into chaos if you're not careful.

That's where Git and GitHub come in. Think of them as your safety net when AI coding goes sideways.

Why vibe coders desperately need Git

Here's the thing about vibe coding: you often don't fully understand what the AI just generated. Sure, it looks right, and it might even work, but what happens when you realize it broke something else? Or when you want to undo that "small refactor" that turned into a complete rewrite?

Without Git, you're basically coding without a parachute.

Git is essentially a time machine for your code. Every commit is a snapshot you can return to, and every branch is a parallel universe where you can experiment without consequences.

Git vs GitHub

I used to think Git and GitHub were the same thing. Spoiler alert: they're not.

Git is the actual version control system that runs on your computer. It works completely offline and tracks all your changes locally. You can use Git without ever touching the internet.
GitHub is a website that hosts your Git repositories online. It's like Google Drive for your code repositories, but with extra features like Issues, Pull Requests, and Actions.

Think of it this way: Git is like having a really good filing system for your documents, and GitHub is like having that filing system backed up to the cloud where others can collaborate with you.

Installing Git (first things first)

Before we can configure Git, we need to make sure it's actually installed on your system. Let's check if you already have it:

git --version

If you see something like git version 2.39.0, you're good to go! If you get a "command not found" error, you need to install Git.

On macOS

The easiest way is using Homebrew (if you have it):

brew install git

Or download the installer from git-scm.com. macOS also comes with an older version of Git that gets installed when you run git for the first time, but I recommend getting the latest version.

On Windows

Download the installer from git-scm.com. It comes with Git Bash, which gives you a Unix-like terminal that's perfect for running Git commands.

On Linux

Most Linux distributions include Git in their package managers:

Ubuntu/Debian:

sudo apt update
sudo apt install git

CentOS/RHEL/Fedora:

sudo yum install git
# or on newer versions:
sudo dnf install git

Once installed, run git --version again to confirm it's working.

Setting up Git (the boring but necessary part)

Before you start, you need to tell Git who you are. Run these commands once:

git config --global user.name "Your Name"
git config --global user.email "your.email@example.com"

That's it. Now Git will stamp your name on every commit you make. You only need to do this once per computer.

The basic Git workflow that changed my coding life

Here's the workflow I use every single day:

1. Check what's changed

git status

This shows you which files have been modified, added, or deleted. I probably run this command 50 times a day. It's like asking Git "what's different since my last commit?"

2. Stage your changes

git add .

This tells Git "I want to include all these changes in my next commit." You can also add specific files with git add filename.js if you want to be more selective.

3. Commit your changes

git commit -m "Add user authentication system"

This creates a permanent snapshot of your staged changes. Write a clear message describing what you did. Future you will thank you for this.

4. Push to GitHub

Before you can push, you need to connect your local repository to a GitHub repository. Here's how:

First time setup:

Create a new repository on GitHub (go to github.com, click the "+" icon, select "New repository")
Copy the repository URL (it looks like https://github.com/yourusername/your-repo-name.git)
Connect your local repo to GitHub:

git remote add origin https://github.com/yourusername/your-repo-name.git
git branch -M main
git push -u origin main

After the first setup:

git push

The first command (git remote add origin) tells Git where your GitHub repository is located. The second command (git branch -M main) ensures your main branch is named "main" (GitHub's default). The third command (git push -u origin main) pushes your code and sets up tracking so future pushes just need git push.

This uploads your commits to GitHub, backing up your work and making it available to collaborators.

I do this cycle constantly – sometimes every 10-15 minutes when I'm actively coding with AI assistance. Each commit is a checkpoint I can return to if things go wrong.

Creating a repository (your project's home)

To start tracking a new project:

git init

This creates a hidden .git folder in your current directory and starts tracking changes.

If you want to work on an existing project from GitHub:

git clone https://github.com/username/repository-name.git

This downloads the entire project and its history to your computer. For example, look how I am cloning a GitHub repo called optisharp to my computer.

Branches: Your experimentation playground

Branches are where Git really shines for vibe coders. Think of them as parallel timelines where you can try things without affecting your main code.

Create a new branch:

git checkout -b experiment/new-feature

Now you can ask AI to implement that crazy idea you had. If it works well, you can merge it back. If it breaks everything, just switch back to your main branch:

git checkout main

And delete the failed experiment:

git branch -d experiment/new-feature

I use branches for literally everything:

fix/header-bug for bug fixes
feature/payment-integration for new features
experiment/ai-suggestions for testing AI-generated code

The .gitignore file (don't commit everything)

Some files shouldn't be tracked by Git. Create a .gitignore file in your project root:

node_modules/
.env
*.log
dist/
.DS_Store

This tells Git to ignore:

node_modules/ (huge folder of dependencies)
.env (contains secret keys)
*.log (log files)
dist/ (build output)
.DS_Store (macOS system files)

Never commit secrets, large binary files, or generated content. Your repository should only contain source code and configuration files.

My vibe coding safety rules

After months of AI-assisted coding, here are the habits that have saved me countless times:

Commit before asking AI to change anything major

Before telling Claude "refactor this entire component," commit your current working state. This gives you an instant undo button.

Use descriptive commit messages

Instead of "updates" or "fixes," write:

"Add user registration form with validation"
"Fix mobile navigation menu bug"
"Refactor database connection logic"

Review AI changes before committing

Use git diff to see exactly what changed:

git diff

This shows you line-by-line what the AI added, removed, or modified. Sometimes AI changes more than you expected.

Push frequently

Don't let a day go by without pushing to GitHub. Your laptop could die, you could spill coffee on it, or you might accidentally run rm -rf in the wrong directory (yes, I've done this).

GitHub: Your cloud backup and collaboration hub

GitHub adds powerful features on top of Git:

Issues: Track bugs and feature requests Pull Requests: Review code changes before merging
Actions: Automate testing and deployment Releases: Tag stable versions of your code

Even as a solo vibe coder, I use GitHub Issues to track what I want to build next. It's like having a todo list that's tied to your codebase.

When things go wrong (and they will)

Undoing your last commit

git reset --soft HEAD~1

This undoes your last commit but keeps the changes in your working directory. Useful when you commit too early or have a typo in your commit message.

Going back to a previous commit

git log --oneline

This shows your commit history. Find the commit you want to return to and:

git checkout abc1234

(Replace abc1234 with the actual commit hash)

Dealing with merge conflicts

Sometimes Git can't automatically merge changes. When this happens, Git will mark the conflicting sections in your files:

<<<<<<< HEAD
Your current code
=======
The conflicting code
>>>>>>> branch-name

Edit the file to keep what you want, remove the conflict markers, then commit the resolved version.

My current vibe coding setup

Here's how I actually use Git and GitHub in my day-to-day AI-assisted coding:

Start with a branch for each new feature or experiment
Commit every 15-20 minutes when actively coding
Push at least once per coding session for backup
Use clear commit messages that explain the "why," not just the "what"
Review AI changes with git diff before committing
Create Pull Requests even for solo projects to review my own work

This might seem like overkill, but it's saved me so many times when AI-generated code broke something unexpectedly.

The honest truth about learning Git

Git has a learning curve. Commands like rebase, cherry-pick, and bisect can seem intimidating at first. But here's the thing: you don't need to master everything on day one.

Start with the basics I've covered here:

git add
git commit
git push
git status
git checkout (for branches)

These five commands will handle 90% of your needs as a vibe coder. You can learn the advanced stuff when you actually need it.

The key is to start using Git now, even if you don't understand everything. It's better to have imperfect version control than no version control at all.

Why this matters for vibe coders specifically

Traditional programmers write code line by line, understanding every character. They might go hours between commits because they're building something incrementally.

Vibe coders work differently. We prompt AI, get large chunks of generated code, test it, and iterate. This creates unique challenges:

Large, sudden changes that might break existing functionality
Code we don't fully understand initially
Rapid experimentation with different approaches
Need to roll back entire features quickly

Git is perfectly suited for this workflow. Every commit is a checkpoint, every branch is an experiment, and every push is a backup of your progress.

Getting started today

If you're not using Git yet, here's what to do right now:

Install Git from git-scm.com
Create a GitHub account at github.com
Run the config commands to set your name and email
Go to your current project and run git init
Create a .gitignore file for your project type
Add and commit your existing code
Create a repository on GitHub and push your code

Don't wait until you "understand Git better." Start with the basics and learn as you go.

Final thoughts

Git and GitHub aren't just tools for professional developers – they're essential safety equipment for anyone doing vibe coding. The ability to experiment fearlessly, knowing you can always undo changes, is liberating.

I've seen too many people lose hours of work because they didn't have version control. Don't be one of them. Start using Git today, commit frequently, and let AI help you build amazing things without the fear of breaking everything.

Your future self will thank you when you can confidently tell Claude Code or Cursor to "refactor this entire codebase" knowing you can always go back to the last working version.

Happy vibe coding!

How to Run Omarchy on a MacBook via UTM

2025-09-02T16:20:24Z

During my college days, I used Manjaro Linux for 4-5 years and I loved it. And I am feeling the same excitement again after learning about DHH's new Arch-based Omarchy Linux distro.

Currently, I use a MacBook M2 Air and do not have another machine to install and use the distro, but I wanted to give it a try. So I tried running Omarchy via UTM (VM for macOS) on my machine, and I finally got it working after almost an hour of trying different settings in UTM. And here's how it looked:

But please note that I wasn't able to actually work on it, as it was considerably slow and laggy. So... install it only if you just want to play with it.

Here's how I got it working...

1. Download Omarchy ISO and install UTM

The very first step is to download the Omarchy ISO from their official website, and save it somewhere on your computer. It was around 1.5 GB in size when I tried, but might change a bit in the future.

Then you have to install UTM by downloading the .dmg from their official website, and installing it by double-clicking on the file, just like how you install any other macOS app.

2. Set up a new virtual machine

Open the UTM app and set up a new virtual machine by clicking on the Create a New Virtual Machine button, and below are the options you have to change – leave options, which I haven't mentioned here, as default.

Select Emulate option, as we have to run another CPU architecture
Select Linux option
Click on the Browse button and select the Omarchy ISO file, and click Continue
Select x86_64 in the Architecture dropdown, leave System as the default
Make the Memory to be 8 GB i.e. 8192 MiB, and click Continue
Either leave the size as 64 GiB or you can make it 32 GiB, click Continue
Optional, but you can select a shared directory path, click Continue
Give your VM a name and Save
Right-click on the VM in UTM sidebar, and select Edit option
Go to the Display section
Select virtio-gpu-pci in the Emulated Display Card dropdown (see screenshot below)
Check the Retina Mode option and Save

Below I am adding some screenshots, in case that's helpful for you during the process.

Let's move to the next and last step now.

3. Start the installation process

Click on the big Play button (see above screenshot), and it will start the installation process. It will ask you some details during the installation process which you can learn more about in the Omarchy documentation.

Now it will take time... a lot of time, actually.

In my case, it took me more than 30 minutes. You have to just let it work in the background and do nothing, maybe grab a cup of coffee or can even take a quick walk outside.

After the installation, it automatically restarts and might again ask you for the details that you just provided during the installation.

But do not move forward.

Instead, shut down the VM, right-click on the VM in the sidebar and select the Edit option. Go to the first IDE option shown in the sidebar below, and click on the Clear button beside Browse to remove the selected Omarchy ISO (see below screenshot for more clarity).

Now Save, and restart the VM by clicking on the Play button. You should be asked to enter your password and see your beautiful Omarchy desktop.

And you're done!

As I have mentioned in the start, this will not be very performant, but you can definitely get a glimpse of Omarchy.

Are Double Quotes Replacing Single Quotes?

2025-07-20T01:16:59Z

Recently, I was editing a document and noticed that I instinctively used double quotation marks (" ") instead of single ones (' '). It made me pause for a second – didn't I grow up using single quotes for things like speech and dialogue?

That led me down a rabbit hole of how quotation mark usage has been changing. And yeah, things have shifted a bit – but it's not as straightforward as "double quotes are taking over single quotes."

It depends on where you're from

In the US, double quotes have always been the default. In the UK, it's traditionally been single quotes. But this line is starting to blur. Some big UK newspapers (like The Telegraph and The Times) now follow what's more common in the US. Even the term "quotation marks" is becoming more common than the older "inverted commas" in Britain.

Fun fact: double quotes were actually more popular in the UK before the 1950s. Single quotes came in later, mainly because they took up less space in print.

But look at today's article in the Telegraph UK, they haven't used any single quote in the whole of the article, but only double quotes. In fact, none of their articles have single quotes anymore.

But... publishing still has its own rules

Publishing houses and editors haven't all switched to one style. The AP Stylebook still prefers double quotes in the US. Meanwhile, British publishers stick to their traditional style – unless the audience is more international. In that case, they might lean American.

Also, with things going more digital, there's pressure to make everything consistent. For example, many digital platforms don't even treat curly quotes properly in search – which is wild if you care about accuracy in research.

Then there's texting, typing, and social media

This is where things get messy. Most of Gen Z doesn't bother with proper punctuation when texting. And I totally get it – it's just faster. Pulling up smart quotes on a mobile keyboard is annoying.

On social media, people have created their own ways to show quotes. Sometimes they don't even use punctuation. They just use formatting, screenshots, or emojis to make a point.

So if you're typing on your phone, you're probably using straight quotes, or skipping them altogether. I do it too, especially in casual messages or tweets.

Style guides are slowly adapting

Style guides from places like Notre Dame and newer journalism groups have started updating their rules. They know people aren't typing the same way they did 10 years ago. So while they still prefer double quotes in formal writing, they're acknowledging that habits are changing – especially online.

The real picture

If you're wondering whether single quotes are disappearing, the answer is: yes, somewhat.

But they're also being used differently depending on the context, and both single and double quotes are still around. It's just that we're now using them based on what feels right for the situation – and honestly, that makes sense.

Calling Myself an Internet Generalist

2025-06-09T16:44:04Z

Starting today, I'm calling myself an internet generalist – because it describes me well.

If you're wondering what that means:

An internet generalist is someone with a broad range of skills and knowledge related to working online. They might be familiar with things like:

Programming
Writing and editing
Online marketing
Graphics design
Leveraging AI, etc.

Basically, they're good at handling many kinds of online tasks and are especially useful in small teams or startups, where people often need to wear multiple hats.

Trying the Sarvam-M 24B Indic LLM

2025-06-04T00:00:00Z

Sarvam AI has released its very first Hybrid Indic LLM called Sarvam-M 24b built on top of the Mistral-Small model (hence the M in the name). It's a text-only model trained on all major Indian languages. You can run it locally on your computer as it's open-source, use on the playground, and also available via API.

I came to know about the launch from X and there are mixed opinions about the launch. But I am going to try it anyway and document my learnings in the post.

The first impression

I skimmed through the launch blog post to see the benchmark and the numbers are impressive when compared against Mistral Small 24B, Gemma 3 27B, Llama 4 Scout 17B/109B, and Llama 3.3 70B. It's claimed to perform:

20% better on Indian language tasks
21.6% better on math tasks
17.6% better on programming tasks

The model is trained to understand and generate text in 10 Indian languages, including Hindi, Tamil, Telugu, Malayalam, Punjabi, Odia, Gujarati, Marathi, Kannada, and Bengali.

As mentioned in the post, they used Supervised Fine-Tuning (SFT), Reinforcement Learning with Verifiable Rewards (RLVR), and Inference Optimization to train the model.

Trying the Sarvam Playground

I visited this URL to access the Playground and signed up using my Google account, and landed on the playground page that looked like this.

I asked it to talk to me in the Hindi language and it immediately replied to me in the language. And it was very fast, definitely faster than ChatGPT and Gemini. If you'd like, below is the exact response that it gave.

But what impressed me the most is its "Text to Speech" tool. When I clicked on the option, it preloaded a line of text in the Odia language and perfectly spoke the language when I clicked on the generate button.

To test further, I gave it the below paragraph in English, asked it to translate to Odia, and then converted it to an audio. I'm putting everything below.

The English text:

The solar system is a group of objects that move around the Sun. The Sun is at the center and is the biggest object in the system. It gives off heat and light that make life on Earth possible. There are eight main planets that go around the Sun: Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, and Neptune. These planets move in paths called orbits.

Translated Odia text:

ସୌରଜଗତ ହେଉଛି ସୂର୍ଯ୍ୟଙ୍କ ଚାରିପାଖେ ଘୂର୍ଣ୍ଣନ କରୁଥିବା ବସ୍ତୁମାନଙ୍କର ଏକ ସମୂହ। ସୂର୍ଯ୍ୟ କେନ୍ଦ୍ରରେ ଅବସ୍ଥିତ ଏବଂ ସୌରଜଗତର ସବୁଠାରୁ ବଡ଼ ବସ୍ତୁ। ଏହା ଉତ୍ତାପ ଏବଂ ଆଲୋକ ବିସ୍ତାର କରେ ଯାହା ପୃଥିବୀରେ ଜୀବନ ସମ୍ଭବ କରିଥାଏ। ସୂର୍ଯ୍ୟଙ୍କ ଚାରିପାଖେ ପରିକ୍ରମା କରୁଥିବା 8ଟି ମୁଖ୍ୟ ଗ୍ରହ ଅଛନ୍ତି: ବୁଧ, ଶୁକ୍ର, ପୃଥିବୀ, ମଙ୍ଗଳ, ବୃହସ୍ପତି, ଶନି, ଅରୁଣ, ଏବଂ ନେପ୍ଚ୍ୟୁନ। ଏହି ଗ୍ରହମାନେ କକ୍ଷପଥ  ନାମକ ପଥରେ ଘୂର୍ଣ୍ଣନ କରନ୍ତି।

And the final audio:

Your browser does not support the audio element.

I can't read the Odia script, but I can speak it, and can say that the audio quality is very good. It speaks perfectly as they speak on the news channels.

I'm very impressed with the output.

Apart from this, they have other tools like Speech to Text, Speech Translate, Transliterate, Translate, and Language Identification. I tried the Speech to Text tool by uploading the same audio in Odia language, and it was able to transcribe it perfectly.

Similarly, other tools are good as well.

One problem though, when I put 2 paragraphs of text in the text-to-speech tool, it doesn't work and just says "internal server error". The error should be more descriptive.

Trying via the API

I received ₹1,000 worth of free credits when I created a new account on the platform, so I also decided to try it via the API and see how it performs.

I went through the docs and created a simple interface to try the API using HTML and JavaScript. Everything is hard-coded, as you can see here:

<!DOCTYPE html>
<html>
<head>
  <title>Sarvam Chat</title>
</head>
<body>
  <h1>Ask Sarvam</h1>

  <input type="text" id="userInput" placeholder="Type your question..." style="width: 300px;">
  <button onclick="callSarvam()">Send</button>

  <h2>Response:</h2>
  <pre id="output">Waiting for input...</pre>

  <script>
    async function callSarvam() {
      const userMessage = document.getElementById('userInput').value;

      const response = await fetch('https://api.sarvam.ai/v1/chat/completions', {
        method: 'POST',
        headers: {
          'Authorization': 'Bearer YOUR_API_KEY_HERE',
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          messages: [
            { role: 'system', content: "you're sarvam, an llm" },
            { role: 'user', content: userMessage }
          ],
          model: 'sarvam-m'
        })
      });

      if (!response.ok) {
        document.getElementById('output').textContent = 'Error: ' + response.status;
        return;
      }

      const data = await response.json();
      const content = data.choices[0].message.content;
      document.getElementById('output').textContent = content;
    }
  </script>
</body>
</html>

You just need to replace YOUR_API_KEY_HERE with your actual API key, and then you can ask questions and get answers on the page. I tried asking a few questions and it did answer as it does on the playground, the text response from the API is fast as well.

Sarvam API pricing

Below is the pricing for different models in Indian Rupees (₹) as presented on the pricing page.

Category	Service	Price
Speech APIs	Speech to Text	₹30 / hour
	Speech to Text & Translate	₹30 / hour
	Speech to Text with Diarization	₹45 / hour
	Speech to Text, Translate & Diarization	₹45 / hour
Language Tools	Translate	₹20 / 10K chars
	Transliterate	₹20 / 10K chars
	Language Identification	₹3.5 / 10K chars
Text to Speech	Text to Speech	₹15 / 10K chars
Analytics	Call Analytics	₹112 / hour

I don't know why they haven't mentioned the pricing for chat completions anywhere on the pricing page, or on any page.

But... do people care about an Indic LLM?

Yes, the question is, do people in India actually need an Indic model like this? Several people like Deedy and Arpit Bhayani mention that there's not enough demand for a model like this and that's why there are only a few hundred downloads of the model on Hugging Face.

I think the main reasons for the low number of downloads are:

very few people care about LLMs in India as of now
most people are end users and won't be downloading the model from Hugging Face, and
this is not marketed well enough, people need to be made aware of what this can do

Honestly, I loved the model. If I have to make a multilingual website then I would prefer Sarvam-M to translate my content over OpenAI's or Gemini's models without any second thoughts.

🗓️ Update: June 4, 2025

The number of downloads on Hugging Face has increased to 269,186 at the time of writing this post. But I am not seeing enough buzz about Sarvam AI on social media and also on YouTube, so it's hard to say if the number is genuine or manipulated.

Overall, I liked the below things:

ability to generate output in Indian languages
formatting and quality of the output
inference speed when asking questions

And a few things that can be improved:

documentation for different endpoints
making people aware of the model

I also recorded a video of myself trying the new Sarvam-M model via the playground and API, and have put my thoughts into it.

That's it.

I am still using and testing the model and will keep updating this page if I learn something new.

Trying the Qwen3-8B Model Locally

2025-05-04T02:42:52Z

I have been hearing a lot of good things about the qwen3-8b model lately, in fact, I also read about it in a post by Simon.

So, I had to try it and I will be sharing my learnings in this post.

Installation

I use Ollama so the installation process was easy, I just ran the following terminal command and the model got installed within a minute. You can visit the Ollama page for qwen3 here.

ollama run qwen3:8b

For the 8b model, it downloaded a 5.2GB file.

Initial testing

At first, I just sent "hi" and only then did I find out that it's a thinking model as its thoughts were being shown between <think> </think> tags. And then it replied with "Hello! 😊 How can I assist you today?" as you can see in the below screenshot.

I am using a MacBook M2 Air 16GB device and the evaluation rate was 16.34 tokens per second, as you can see in the above screenshot.

Coding test

I asked it to generate a simple tic-tac-toe game by giving it the following prompt:

create a tic tac toe game in python

And, to my surprise, it created the best tic-tac-toe game I have ever played in the terminal and it ran without any errors. If you want to take a look, below is the Python code that it gave me:

def check_winner(board, player):
    # Check rows
    for row in board:
        if row[0] == row[1] == row[2] == player:
            return True
    # Check columns
    for col in range(3):
        if board[0][col] == board[1][col] == board[2][col] == player:
            return True
    # Check diagonals
    if board[0][0] == board[1][1] == board[2][2] == player:
        return True
    if board[0][2] == board[1][1] == board[2][0] == player:
        return True
    return False

def is_draw(board):
    for row in board:
        if ' ' in row:
            return False
    return True

def print_board(board):
    for row in board:
        print('|'.join(row))
    print()

def main():
    board = [[' ' for _ in range(3)] for _ in range(3)]
    current_player = 'X'

    while True:
        print_board(board)
        while True:
            try:
                move = int(input(f"Player {current_player}, enter your move (1-9): "))
                if 1 <= move <= 9:
                    row = (move - 1) // 3
                    col = (move - 1) % 3
                    if board[row][col] == ' ':
                        board[row][col] = current_player
                        break
                    else:
                        print("Cell already occupied. Try again.")
                else:
                    print("Invalid input. Please enter a number between 1 and 9.")
            except ValueError:
                print("Invalid input. Please enter a number between 1 and 9.")

        if check_winner(board, current_player):
            print_board(board)
            print(f"Player {current_player} wins!")
            break
        if is_draw(board):
            print_board(board)
            print("It's a draw!")
            break
        current_player = 'O' if current_player == 'X' else 'X'

if __name__ == "__main__":
    main()

It looks like this when you play the game - it perfectly handles the win, lose, and draw cases.

| | | |
| | | |
| | | |
Player X, enter your move (1-9): 1
|X| | |
| | | |
| | | |
Player O, enter your move (1-9): 5
|X| | |
| |O| |
| | | |
Player X, enter your move (1-9): 3
|X| |X|
| |O| |
| | | |
Player O, enter your move (1-9): 7
|X| |X|
| |O| |
|O| | |
Player X, enter your move (1-9): 9
|X| |X|
| |O| |
|O| |X|
Player O, enter your move (1-9): 4
|X| |X|
|O|O| |
|O| |X|
Player X, enter your move (1-9): 6
|X| |X|
|O|O|X|
|O| |X|
Player O, enter your move (1-9): 8
|X| |X|
|O|O|X|
|O|O|X|
Player X, enter your move (1-9): 2
|X|X|X|
|O|O|X|
|O|O|X|
Player X wins!

But the only issue was, it took approximately 12 minutes to give the output as it kept thinking and thinking. I am sure that it's due to my computer's power, and it would have been faster on a computer with higher configuration.

If you want to take a look at the entire output, including the <think> tags, you can click here to see this .txt file.

Apart from this, I asked multiple simple coding and tech related questions and I'd say that I am very satisfied with it. It performs surprisingly well for its size.

Learning about sqlite3 WASM

2025-04-24T01:22:40Z

I love sqlite3 and have used it for a few simple projects, but I recently came to know that Notion uses sqlite3 WASM in the browser for client-side caching – they have been able to improve their page navigation times by 20% by doing so.

I found it really interesting, so I started reading more about it. Basically, this post is just my notes on the topic – I will be noting down whatever I read.

What is sqlite3 WASM?

sqlite3 WASM or WebAssembly is a version of the SQLite database that's built to run in web browsers using WebAssembly. It lets you use a full SQLite database directly in the browser, powered by JavaScript and compiled C code, without needing a server.

And this version is officially supported by the SQLite team.

Features

Runs the complete SQLite engine within the browser using WebAssembly while supporting standard SQL queries and database operations without server-side components.
Supports multiple JavaScript APIs, like:
- Low-level C API bindings that provide direct access to SQLite's C API
- High-level object-oriented API that offers a more JavaScript-friendly interface
- Worker-based API that enables operations in web-workers to prevent blocking the main thread
- Promise-based API that simplifies asynchronous operations with a Promise-based interface
Utilizes the OPFS (Origin Private File System) for persistent storage, so that the data remains available across sessions.
Allows the creation of virtual tables and table-valued functions directly in JavaScript and also supports custom builds with additional features or optimizations.

How Notion is using it

Earlier, Notion was using IndexedDB for storing data in the browser but it had issues like storage limits and inconsistent performances across different browsers, so they switched to sqlite3 WASM solving all these issues.

Notion uses OPFS to store data locally - persistent across sessions
To avoid slowing down, they run database operations in Web Workers in the background
Only the active tab handles all database writes, and other tabs send their request to this active tab

Here's how they explain this:

[...] only one tab is permitted to actually use its Web Worker. A SharedWorker is responsible for managing which is the "active tab." When the active tab closes, the SharedWorker knows to select a new active tab.

To execute any SQLite query, the main thread of each tab sends that query to the SharedWorker, which redirects to the active tab's dedicated Worker. Any number of tabs can make simultaneous SQLite queries as many times as they want, and it will always be routed to the single active tab.

I also found a great discussion on the topic on GitHub that you must check out.

I recommend reading the blog post by Notion as they have explained all the issues they were encountering and how they fixed it.

Who uses sqlite3 WASM

Some notable examples would be:

Notion: as we already discussed in the post
SQLime: an online SQLite playground that runs entirely in the browser
Evolu.dev: a local-first platform designed for developers

Resources to learn more

That's it.

I will be reading more about it, and will keep this post updated.

Trying the LibreWolf Browser

2025-04-21T00:00:00Z

While browsing the r/browsers on Reddit, I came across the name LibreWolf multiple times and then I finally decided to give it a try. Earlier, I tried the Ungoogled Chromium browser and it was unable to become my default browser for certain reasons.

This is not going to be a very technical post, instead, I will just be sharing my experience about what I liked and disliked. So... let's start from the start.

1. Installation

I am using a MacBook Air M2 and the installation process seemed straightforward initially. I could install it through Homebrew by running the following command, or download the .dmg file and then install.

brew install --cask librewolf

I used the Homebrew method and it got installed after a minute. But when I tried opening the app, it didn't open and showed the following error dialog. For your information, currently, I'm on the latest macOS Sequoia 15.4.1.

I started looking and found this Reddit thread, tried a bunch of things, and finally found a solution. I have briefly explained about the same in this post.

Finally, I got it to open.

2. Things I liked

I liked how clean it looked, but I went one step further and disabled shortcuts and recent activity from showing on the homepage and then it looked even cleaner.

Now, let's go through the things I liked.

Comes with uBlock Origin preinstalled

Yes, I didn't even have to install an adblock extension as it already came with the uBlock Origin extension installed. The extension was also already pinned to the toolbar, as you can see in the top-right of the above screenshot.

In fact, after Google Chrome started enforcing the Manifest v3 for extensions, most of the Chromium-based browsers don't support the uBlock Origin out of the box now. And as LibreWolf is Firefox based, that's not an issue here with the extension.

Supports Firefox sync

It needs to be enabled from the settings, but the browser does come with the Firefox Sync feature. After enabling it, you can sign in to your Firefox Sync account or create a new account, and the sync starts working.

You can also copy-paste this about:preferences#sync in your address bar and it will take you to the sync page. But obviously, it's optional.

Vertical tabs

I am not a fan of vertical tabs but I liked that it has the option to switch between horizontal and vertical tabs with just a click.

For this, you'd go in the Browser Layout section on the about:preferences#general page, as shown above. From here, the sidebar can also be enabled.

Forces web content to use light theme

By default, the ResistFingerprinting feature is enabled so the browser doesn't let websites see your device settings (whether it's on dark/light mode) and forces websites to show their content in the light mode only.

I prefer light mode, so it's not a problem for me. But if you don't like it, you will have to disable the feature and that will make the browser a bit less secure.

Hardened security settings

I really liked how the security on the browser is super-hardened out of the box.

For example, the "Delete cookies and site data when LibreWolf is closed" feature is turned on by default, which means all cookies will be cleared when you close the browser and you will be logged out from all websites. I don't need this, so I have disabled it.

Similarly, there are other options also that I liked:

Multiple DNS over HTTPS providers
Ask to save passwords, addresses, and payment methods is turned off by default
HTTPS-only mode is enabled

Multiple profiles option

Though the profiles option needs to be turned on manually, it's a great feature. I had to go to about:config, search for browser.profiles.enabled, and set it to true.

I created two profiles – personal and work – and gave each a different color so that they are easily identifiable. I also really liked the fact that both profiles open as separate apps. I added them both to the Dock, so I can open any profile with just one click.

I found this Reddit discussion to be very helpful when doing all this.

3. Things I didn't like

Apart from the things I liked, I also didn't like the fact that "profiles" option is not turned on by default.

That's it.

Update:

To be honest, security-wise, I liked LibreWolf the most out of all the browsers I have used as of now.

But I found the profile switching and Dock icons for different profiles to be buggy. For example, if I open two different profiles then I see two different icons in the Dock, great, but when I close both profile windows, clicking on Dock icons do not open different profiles.

Sometimes, it becomes very confusing.

For now, I am sticking with the Brave browser, until I find something else.

Trying the Ungoogled Chromium Browser

2025-04-18T00:00:00Z

So... I tried switching to the Ungoogled Chromium browser as my main browser, instead of the Brave browser that I had been using before. To be honest, I sometimes find Brave's push for crypto and AI a bit annoying, and that's what made me look for an alternative. I've tried a few browsers before, so this time I thought I'd give Ungoogled Chromium a shot.

In this blog post, I will explain the installation process, first impressions, what I liked, what I disliked, and whether I will be using this as my main browser or not.

The installation process

I am, currently, using the MacBook Air M2 as my main computer and the installation process was very easy. I installed the ungoogled-chromium version via Homebrew by running the following command in the terminal, which took around 30 seconds to complete.

brew install --cask ungoogled-chromium

I opened the browser, and was greeted by this ungoogled-first-run screen that you can see in the screenshot below. It looked very clean at first and I wasn't asked to log-in in order to sync my settings as Google Chrome normally does.

Now, it was time to test it properly.

Testing as per my use-cases

1. Changing the default search engine

At first, there was no default search engine set so I opened settings and selected DuckDuckGo (which was pre-listed among Bing and a few others, but no Google) as my default search engine. By the way, one can also add Google Search by clicking on the Manage search engines and site search button.

2. Installing Chrome extensions

I visited the Chrome Web Store and opened random extensions, but wasn't able to install as it was showing an error of "Item currently unavailable".

I directly visited the uBlock Origin's GitHub repo and downloaded the .zip file for the Chromium build. The extension got installed with no errors and was working perfectly as well.

However, I noticed their instructions that explained a way that enables the Ungoogled browser to install any Chrome extension like you normally do. For that, I had to enable a flag in the chrome://flags and install a Chrome extension called chromium-web-store.

After following the steps, the "Add to Chrome" button started showing on all extensions from the Chrome Web Store, as you can see in the screenshot above. By the way, X Mute is a Chrome extension that I have created – it can mute multiple words/phrases on X (Twitter) at once, and not to mention, it's free to use.

3. Profiles and developer tools

Somewhere I read that the Ungoogled Chromium browser doesn't support creating multiple profiles, but that's not true now. I successfully created two profiles named personal and work.

I also tried opening the developer tools and it worked as expected – just like how it does in the Google Chrome browser.

4. Gmail and YouTube

I also logged into Gmail and it does work, and it stays logged in even after I quit and re-open the browser. YouTube works perfectly as well, no lags, or no missing features - theatre and fullscreen modes worked as well.

I also logged into X (Twitter), and it also worked as expected.

5. Secure DNS and Google

I didn't expect that the "Use secure DNS" feature would be there in the browser, but it was there and worked as expected. I normally use Cloudflare's 1.1.1.1 DNS resolver which reduces the latency a bit and also makes everything neutral. I was able to turn it on and use it.

Also, I noticed a funny thing that it says "You and Google" but Google Sync doesn't work as it's disabled (which does make sense).

6. DRM issues

I tried opening a few Udemy courses to test the DRM features and it didn't work. Some courses played without any issues, but DRM protected courses didn't play, even after trying multiple times.

The workaround could have been to follow this tutorial on their FAQ page, but I didn't have that much patience. It's something like, you'll have to download the Google Chrome official installer file, mount it, and run a terminal command to install the Widevine CDM.

7. Benchmark testing

I used the BrowserBench Speedometer to run tests on the Ungoogled Chromium I installed and also on the Google Chrome browser that I already had installed. To my surprise, Google Chrome scored a bit higher than the Ungoogled browser.

The left is Google Chrome stat (33.0) and the right is the Ungoogled Chromium stat (31.2). But I don't think it's a deal-breaker, as the difference isn't much.

8. Experienced a bug

Lastly, I experienced a weird bug as well. The uBlock Origin extension that I installed manually, automatically got uninstalled when I quit the browser using cmd + q and re-opened it. I installed the extension again and then it again got uninstalled.

This bug has now made it a difficult choice for me to permanently switch to this browser. But I am still testing it for a few days, and let's see if I change my mind.

For now, I will keep using the Brave browser.

Update: Apr 18, 2025

After using the browser for more than a week, I have decided not to use this as my default browser, in fact, I have uninstalled it. And the main reasons are minor bugs that I mentioned, and also the very late security updates.

After this, I will be trying the LibreWolf browser and let's see if that meets my expectations.

MP3Detective: AI-Powered Music Metadata Manager

2025-04-06T02:31:03Z

I have a huge collection of MP3 files for Hindi songs, and most of them have incorrect or missing metadata (like song name, artist, album, etc.). I tried many online tools but none of them worked well, especially for old Bollywood songs.

So, I decided to build my own tool using OpenAI's GPT-4o model. And... say hello to MP3Detective – a Python tool that automatically finds and updates MP3 metadata.

How it works

The tool is quite simple. You just:

Put your MP3 files in the input folder
Run the Python script
Get your updated files in the output folder

The best part? It works with any language or music genre. I tested it with my old Hindi songs collection, and it worked with about 95% accuracy. Yes, it did make some mistakes with very old or rare songs, but that's expected.

I also have a quick video showing how it works:

Building the tool

I used Python to build this tool because it has great libraries for handling MP3 files. The main pieces are:

OpenAI's GPT-4o for identifying song details
eyeD3 for reading/writing MP3 tags
tqdm for showing nice progress bars

Here's the folder structure of how everything is placed:

mp3detective/
├── .gitignore        # Git ignore rules
├── app.py            # Main application file
├── requirements.txt  # Python dependencies
├── README.md         # This documentation
├── input/            # Place your MP3 files here
└── output/           # Updated files will appear here

The tool creates a copy of your original files, so you don't lose anything. It also keeps a detailed log of what it's doing, which helps if something goes wrong.

Real-world testing

I tried it with about 1,500 old Hindi songs first. Here's what I found:

For most songs, it found the correct details
Some very old songs (1950s-60s) were tricky
Sometimes it couldn't decide between two similar song versions
The original files stayed safe in the input folder

And this is what it shows in the terminal after the process finishes.

Using it yourself

Want to try it? It's pretty simple:

Get the code from GitHub
Install Python if you don't have it
Add your OpenAI API key
Put your MP3 files in the input folder
Run the script

That's it! The tool will do its magic and you'll find your updated files in the output folder.

The code is open source, so feel free to try it out or even make it better!