Tech — eBits Blog

Connect to college WiFi using nmtui or networkmanager

Amiitesh TSP — Tue, 13 Jan 2026 21:02:57 +0530

Connecting to college WiFi using nmtui #

Step 1: Open a terminal and run nmtui and in the selection navigate to activate a connection

Step 2: From the list, select the WiFi you want to connect to.

Step 3: You’ll be taken to a screen similar to the one below:

Step 4: Verify that the SSID matches the network you want to connect to, then configure the settings below:

Authentication -> PEAP (Protected PEAP)
Anonymous Identity -> Nil
Domain -> Nil
CA cert -> Nil
CA cert password -> Nil
Inner authentication -> MSCHAPV2

Step 5: After configuring the settings as said below, enter your username and password and press enter.

Following the above steps will get you connected to the college WiFi. If you feel difficult to connect through the terminal interface. Refer to GUI method below.

Connecting to college WiFi using NetworkManager GUI #

Step 1: Open the application -> Advanced Network Configuration

Step 2: From the dropdown menu, Select WiFi and enter Create…

Step 2: Under the WiFi tab, enter the name of the WiFi connection that you want to connect to in the SSID field.

Step 3: Now after that go to the WiFi Security tab, you’ll see a configuration window similar to the one below:

Step 4: Under WiFi Security, check if SSID is the network you want to connect to under the WiFi tab and after that under the WiFi Security tab change the settings to the one below:

Security -> WPA/WPA2 Enterprise
Authentication -> PEAP (Protected PEAP)
Anonymous Identity -> Nil
Domain -> Nil
Check the “No CA certificate is required” checkbox
CA cert -> Nil
CA cert password -> Nil
Inner authentication -> MSCHAPV2

Step 5: After configuring the settings as said below, enter your username and password and press enter.

Following these steps will get you connected to the college WiFi

Is Wayland better than X11

Amiitesh TSP — Sun, 11 Jan 2026 13:07:25 +0530

Introduction #

Wayland and X11 are one of the most prominent display servers. Both of them have their fair share of advantages and disadvantages. While, all the Desktop Environments, Window Managers are switching to Wayland due to it being a better alternative. But what are the differences between these two and why are users and developers switching to Wayland over X11. I’ll try my best to give my opinion on both of these display servers.

What is a Display Server? #

In Linux, A display server is a crucial component that acts as a intermediary between graphical applications and the hardware that is responsible for displaying them. It manages the graphical diplay and user input from input devices like keyboard and mouse.

X11 Display Server #

I’ll first talk about the older display server. The X11 project began in 1987 and has the stable support for almost all the linux native software. X11 follows the client-server protocol where the X server owns all the screens and input devices and all the GUI applications are the clients of the X server. It was specifically designed to work over a network it assumes clients and the server may be on different machines which leads to serialization and backwards-compatibility. It was built with assumptions but most of them no longer holds true. As of today, Linux runs on locally connected displays which is not something that X was designed for. This became increasingly problematic as modern computing kept evolving.

By the early 2000s, X11 was seriously backward technically. Linux ecosystem was evolving which made most of X11’s features really unneccessary. Libraries like libinput started managing fonts which was a priviledge that only X11 had. Cairo and Freetype took over rendering which was earlier done by X11. Yet, X11 was still there with much of unneccessary feature which was seen as a bottleneck.

Architecture #

The kernel gets an event from an input device and sends it to the X server through the evdev input driver and the kernel does all the job from controlling and translating the protocol into the required standard.
The X server then decides which window the event affects and sends it to that specific client. But X does not know how to do it properly since the windows are controlled by the compositor.
The client looks at the event and has to decides. The UI has the change when the user controls it. So, the client sends the rendering request to the X server.
After recieving the request, the X server sends it to the hardware to let it render the UI. Meanwhile, the server calculates the bounding region and sends it to the compositor as a damage event.
The damage event tells the compositor that something has happened to the screen and it has to recomposite the entire screen with the changes.

Wayland Display Server #

Architecture #

The kernel gets an event and immediately sends it to the compositor.
The compositor looks through the scenegraph to see which window get the event.
As in the X case, when the client receives the event, it updates the UI in response. But in the Wayland case, the rendering happens in the client, and the client just sends a request to the compositor to indicate the region that was updated.
The compositor collects damage requests from its clients and then recomposites the screen. The compositor can then directly issue an ioctl to schedule a pageflip with KMS.

Wayland is faster than X11 #

In X11, the client talks to the X server -> X server talks to the window manager -> Window Manager to the compositor and finally the GPU. But in Wayland, the client directly interacts with the Compositor then to the GPU. X11 has to go through many steps which makes it slower and bloated when compared to Wayland.

In X11, the application renders to pixmap, and the pixmap is copied to X server and the compositor has to copy again and the GPU finally displays it. But in Wayland, the application directly renders to the GPU buffer and the compositor just has to reference it from the buffer.

Bottom Note #

Both the compositors have both of their pros and cons. X11 is more stable and has a mature codebase and it has a very predictable behaviour. X11 is ideal for screen recording remote desktops and has support for almost every software due to its maturity and a longer existence than Wayland. It is easier to write code for X11 and build low level tools. At the same time, It has many security flaws and broken features. The project is almost dead and many distros have continued to drop X11 as the default display server.

Wayland on the other hand, Wayland is faster than X11 because of the Zero-copy rendering and its more secure since it allows the applications to see only their input and their own surfaces. It has almost perfect frame timing, the compositor controls VSync, frame scheduling and presentation timing which prevents screen tearing. At the same time, its harder to write wayland clients, has weaker remote desktop control when compared to X11 and harder to write low level tools. It is still evolving and many of its protocol extensions are still changing constantly. Many software are yet to extend compatibility to Wayland and iss still growing at a faster rate.

SSH for remote git repos

Amiitesh TSP — Wed, 31 Dec 2025 21:52:16 +0530

Introduction #

There are different ways to connect to a remote git repository like GitHub, CodeBerg, GitLab, etc:

HTTPS
SSH

HTTPS is for beginners and for casual coding and SSH on the other hand is more secure, easy to work with and used by professionals and few beginners.
The setup is fairly easier and once setup is really easy to work with.

Setup #

Step 1: Generate a ssh key #

ssh-keygen -t ed25519 -a 100 -f ~/.ssh/git -C "git@tspamiitesh@gmail.com"

Step 2: Start the ssh agent #

eval "$(ssh-agent -s)" # Depends upon the shell
ssh-add ~/.ssh/git

Step 3: Add ssh public key to GitHub #

cat ~/.ssh/git.pub

Then,

Open GitHub (or any remote git service) → Settings
Go to SSH and GPG keys
Click New SSH key
Paste the key
Save

Step 4: Test the ssh connection #

ssh -T git@github.com

Step 5: Config File #

Host *
AddKeysToAgent yes
IdentitiesOnly yes
PreferredAuthentications publickey
Host github.com
HostName github.com
User git
IdentityFile ~/.ssh/git

The above configuration is a really basic one and you can add up on many other features

This is one of the most simplest ways to setup ssh

Tech Wrapped

Amiitesh TSP — Mon, 29 Dec 2025 10:23:03 +0530

Tech Wrapped 2025 #

This post is a personal wrap-up of my year in tech, the stack I relied on, the software that shaped my daily workflow, and the projects I built throughout 2025.

The goal isn’t to list everything I touched, but to document what actually mattered.

Tech Stack #

This year, my stack gradually converged toward tools that emphasized simplicity, control, and long-term maintainability.

Languages #

Zig: I have always been a fan of C, but trying out Zig was a really good experience. I loved the syntax, its interoperability with C, and its strong support for bare-metal programming and embedded systems.
Golang: I started getting into network programming and felt that C was a bit hard to work with for those use cases. That led me to Golang, which I really liked because of its goroutines and channels. Although I’m not a big fan of garbage collectors, I felt that sacrificing manual memory management for a better experience in hobby network programming was actually a good trade-off, in my opinion.

Software I Used & Loved #

Some software faded away quickly. The ones listed here earned a permanent place in my workflow.

Daily Drivers #

River: I was a Hyprland user and wanted to try out a more lightweight window manager, as Hyprland felt a bit too much for me. While exploring lightweight options, I came across a window manager written in Zig. That’s how I found River, one of the more prominent projects built in Zig. After trying it out, I really liked it, especially its approach to configuration as a script and tools like riverctl.
Ghostty: I didn’t really plan to switch terminal emulators from Kitty. I tried Ghostty just for fun, but ended up liking it enough to make the switch.

Notes and Documentation #

Neorg Plugin: I was an Obsidian user for note-taking and really wanted to try an open-source alternative (FOSSification). While scrolling through Reddit, I came across the Neorg plugin in a subreddit. It’s essentially an Org-mode like system for Neovim, and I ended up switching to Neorg. I do realize that Org mode already exists, but I wanted to try something a bit more niche and tightly integrated with Neovim.
Typst: I was using LaTeX for my college reports and for taking math notes, but its syntax has always been an obstacle that slowed me down. I came across Typst, which has a much easier learning curve and a far less overwhelming syntax. It follows a syntax style similar to Markdown, which made writing and iterating on notes much faster.

Contribution #

Ly: Things I have contributed around 162 lines to Ly display manager
- Improved Power Management Options: Added a hibernate option between sleep and brightness-down actions, giving users finer control over power behavior, especially useful for laptops. #867
- Customizable Edge Margins: Introduced an edge margin option, allowing better layout control and improved ergonomics for different screen sizes and setups. #856
- Battery Status Logic Fix: Fixed an issue where the battery status defaulted to an incorrect row when certain UI elements were hidden, ensuring consistent and predictable behavior. #845
- Battery Status in the Top Bar: Added battery status support directly to the top bar alongside brightness controls, improving visibility and reducing the need for extra UI elements. #826

Projects I Built in 2025 #

Some small projects that I built this year

Completed Projects #

Simple 4bit Processor #

Description: This was for a college project for the subject Digital System Design
Tech Stack: Verilog, GTKwave
Core Problem Solved: A really simple 4bit processor.
What I Learned: Core VLSI perspective of a processor.

Multi Threaded File Downloader #

Description: This is a multi-file downloader in Golang utilising Go channeling and Goroutines
Tech Stack: Golang
What I Learned: Golang in computer networks

GortScanner #

Description: This is a really simple port scanner that I made in Golang
Tech Stack: Golang
What I Learned: Golang in computer networks

Ongoing / In-Progress Projects #

Fastsh #

Goal: A POSIX-complaint shell that I am working on for my personal use cases.
Tech Stack: Zig
Current State: It can execute some basic builtins and executables in PATH.
Remaining Challenges: Implement features like job management, conditional statements and much more.

Links #

GitHub: https://github.com/embeddingbits/

Typst vs LaTeX

Amiitesh TSP — Wed, 03 Dec 2025 00:00:00 +0000

Introduction #

We are in an era of arising “modern” alternatives. Almost all of the software and hardware products that we are using has a modern alternative.

People were using Vim and now there is an alternative called Neovim. C/C++ has modern alternatives like Rust and Zig. Zoxide is a better alternative of the cd command. Zellij is an alternative of tmux.

Similarly, LaTeX has an easy alternative called Typst. LaTeX has been the best in what it has been doing for the past 4 years. LaTeX is a document preparation system and a typesetting language that is used to create professional documents which extensively uses complex scientific and mathematical equations.

Typst, similarly is a document preparation system which borrows its ideas and syntax from Markdown, LaTeX and other programming languages. It is much simpler than LaTeX, easier to debug and faster to prepare.

Typst is still developing and its growing much faster whereas on the other hand, LaTeX is much powerful and has been the standard for most of the research papers and articles.

Syntax #

\documentclass{article}

\begin{document}

\section{Introduction}
This is the introduction to the document.

\subsection{Background}
Details about the background of the topic.

\subsubsection{Historical Context}
A brief overview of the historical context.

\section*{Acknowledgements}
Special thanks to everyone involved.

\end{document}

#set heading(numbering: "1.")

= Introduction
This is the introduction to the document.

== Background
Details about the background of the project.

== Historical Context
A brief overview of the historical context.

== Acknowledgements
Special thanks to everyone involved.

This is just a really simple demonstration to show the simplicity of LaTeX, but in larger documents LaTeX uses many macros and importing of several other libraries to achieve a simple structured document.

Similarly, writing math equations in Typst is really simpler than LaTeX

LaTeX

The quadratic equation is given by $x = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a}$.

Typst

The quadratic equation is given by $x = (-b plus.minus (sqrt(b^2 - 4 a c))) / (2a)$

Typst is less cluttery to look at than LaTeX.

Differences #

Learning Curve #

LaTeX: It has a really steep learning curve and a lot of packages to learn.
Typst: It is really to learn and its much flatter than LaTeX.

Compilation #

LaTeX: Compilation times are really long and debugging is really hard in LaTeX.
Typst: Rapid compilation times and debugging is really than debugging in LaTeX.

Language #

LaTeX:
- The markup is really visible than the actual content.
- There are many macros in the language
Typst:
- The syntax is really simple and the markup stays out of the way when editing.

Packages #

LaTeX: There are many packages that are old and new and almost everything exists.
Typst:
- Fewer packages than compared to LaTeX.
- The number of packages are rapidly growing
- Many built-in functions which reduce the need for third party packages.

Use Cases: When to Use What #

Use Typst When #

You want speed in writing and compiling.
You’re writing:
- Homework/assignments
- Reports
- Thesis drafts
- Technical documentation
- Notes
You want good output without fighting the compiler.
You need custom formatting or programmatic layouts.
Best for:
- Students
- Engineers
- Technical writers
- Fast prototyping

Use LaTeX When #

You are submitting to a journal/conference that requires LaTeX.
You need:
- Highly specialized math packages
- Complex bibliography/citation requirements
- TikZ-based graphics
- Perfect control for scientific publications
You’re using a template that only exists in LaTeX.
You’re producing textbooks, research papers, or books where full TeX power is necessary.
Best for:
- Academics
- Scientific publishing
- Journals, IEEE/ACM submissions
- Math-heavy textbooks
- Established research workflows

Bottom Note #

Both softwares are excellent in their own ways. LaTeX has been around since 1984 and is more mature, stable, and extensively documented. Its the industry standard for research papers, academic publishing, complex mathematical typesetting, and large technical documents.

Typst, introduced in 2023, is a modern alternative that focuses on speed, simplicity, and a more intuitive syntax. It is especially useful for class assignments, note-taking, project reports, and general documentation, where quick iteration and readability matter more.

While LaTeX still dominates in formal publishing workflows, Typst is rapidly evolving and becoming a strong choice for students and developers who want clean, beautiful documents with less overhead.

Links #

Typst
LaTeX

Guide to QEMU as a Virtual Machine

Amiitesh TSP — Tue, 25 Nov 2025 00:00:00 +0000

Why QEMU? #

There are lots of virtual machine software like VirtualBox and VMWare. But why specifically QEMU?

So, firstly, QEMU can emulate any software hardware:
- ARM
- AArch
- RISC-V
- MIPS
- PowerPC
It does full system emulation like CPU, timers, interrupts, UART, SPI/I2C. VMWare and VirtualBox do not emulate real hardware, they virtualise generic PC hardware. QEMU gives you near native performance and deeper kernel intergration and is highly scalable.
There are many customisation that is possible with QEMU, it has virt-manager which provides a GUI to manage the VMs or we can use the normal command line.
They can easily be automated with either scripts or Makefiles.
They have really advanced I/O and storage features like Copy on Write (CoW), qcow snapshots and backing up files.
This is really useful when it comes to building Operating systems for different architecture while working in a system with another architecture and its really useful for baremetal embedded systems projects and experimenting with other architectures.

Using QEMU to boot an ISO #

To create a VM, we have to initialise a virtual hard disk.

qemu-img is used to create and convert virtual hard disk files.
create flags tells qemu-img to create a virtual hard disk.
-f qcow2 (QEMU Copy on Write) is the file format for QEMU, it is the native format for QEMU.
Then os_image.img is the name of the image that we are going to create and 10G is the size allocation, this can be set according to user preference.

qemu-img create -f qcow2 os_image.img 10G

Next up, to launch the VM from a iso

qemu-system-x86_64 runs the qemu emulator for 64 bit x86 systems, this is available for almost all the other architectures too.
-enable-kvm is to enable hardware acceleration using KVM (Kernel-based Virtual Machine).
-cdrom <iso_name> specify the iso file as the CDROM file.
-boot menu=on is enables a small boot menu at VM startup so you can choose boot device
-drive file=os_image.img is attached.
-m 2G is the RAM that we are going to allocate for the virtual machince to function. This is dependant on user preferences and the system capability.

qemu-system-x86_64 -enable-kvm -cdrom os.iso -boot menu=on -drive file=alpine.img -m 2G

The AI browser hype

Amiitesh TSP — Wed, 05 Nov 2025 00:00:00 +0000

What is an AI Browser? #

So, basically an AI Browser is something that integrates Artificial Intelligence to automate tasks, summarise pages and much more. There were 0 to no AI Browsers until July when Perplexity decided to beta launch Comet on July 22nd.

People are going crazy over this hype, they are booking tickets (by filling all the required details), applying jobs (submitting resume, filling up the questions and forms). The new term for stuff like these are called Agentic Browsing.

Are they safe? Do they ensure privacy? #

Now asking the real question, how safe are they and whether they ensure privacy.

Personally, I’m nowhere closer to using an AI Browser, I have a fair share of important accounts logged in and I dont trust an LLM with my information. You’re basically giving a rock that was trained with mathematics to deal with your browser automation, filling tickets, automating payments. AI does not know to differentiate between genuine prompts and prompt injection attacks.

For the people who aren’t aware of prompt injection, it’s a cyberattack made to exploit LLMs to perform unintended action. I saw this really interesting article where a user had performed a prompt injection as a reddit comment.

In this injection, a comment in the post’s comment section sends a request to the Comet AI browser to open a link and then email certain details to a specified address, all without the user’s confirmation.

Another common form of prompt injection involves providing a PDF containing ANSI escape characters or whitespace language and asking the AI to read it. The AI then executes the actions embedded in the ANSI escape sequences instead of following the user’s actual request.

Personally, I don’t owe my information to a malicious PDF or a reddit comment section. Opera has it’s own AI browser called the Opera Neon, and Opera themselves have warned about prompt injection:

We are nowhere near eliminating prompt injections in the near future, since it purely depends on the user to prevent the browser from falling for the injection attacks. Google has made an effort to prevent prompt injection which ultimately makes the AI dumber than what it usually was.

LLMs are very prone to unexpected behaviour and will remain the same for at least the next few years, the market hype has led people to avoid researching a particular topic, tool, or software, resulting in major bugs and unexpected behavior being left unfixed. This leads to shorter release cycles that create more problems than a well-researched release would.

I wanted to write about this since I’ve been noticing a lot more usage of AI browsers without precautions and side effects :(

Bottom Note #

Browsers have been there for a while and they are one of the best creations of mankind and I can’t imagine a world without them. They are also mature in terms of security as a result of multiple years of optimisation, fixes, reasearch and more.

The sense of an AI browser breaks years of maturity of security enhancement due to a software browsing on behalf of the user with or without the user’s confirmation.

If we are still planning on using an AI browser, it is our responsibility to monitor every single action taken by the AI on behalf of the user and be a responsible digital user.

Thanks to Adam Convey on providing insights: article

Configuring Tmux

Amiitesh TSP — Tue, 04 Nov 2025 16:28:33 +0530

Introduction #

Welcome to this blog where I will be taking you through certain steps to get your own tmux configuration.

First of all, let’s see: What is Tmux? and Why is it used?

Tmux stands for Terminal Multiplexer and is used in Unix-like operating systems. It allows you to use multiple terminal sessions in a single terminal window. Even if the actual terminal window closes, the tmux session runs in the background and can be accessed with the name of the session — which is helpful when we accidentally close the session without saving changes.

Here’s how we can use tmux:

In the above video, I opened a tmux session, created three split panes, created a tmux window, closed the terminal, and reattached using the session name "test".

The default configuration for tmux is good, but we can add our own plugins, colorschemes, custom keybinds, and more. Configuring tmux is not a tough job and is relatively easy. I use a simple minimal tmux configuration — and I’ll take you through the steps to achieve it.

Getting Started #

To begin, locate the tmux configuration file:

~/.tmux.conf

Open it with your favorite editor.

The first step is to create a shortcut to reload the config without restarting tmux:

unbind r
bind r source-file ~/.tmux.conf

Now press Ctrl+s, then r to reload the config instantly.

Rebinding the default prefix #

By default, tmux uses Ctrl+b as the prefix. This is not ergonomic.

We’ll change it to Ctrl+s (you can choose any):

set -g prefix C-s

Now your config looks like:

unbind r
bind r source-file ~/.tmux.conf
set -g prefix C-s

Adding mouse support #

Tmux is keyboard-driven by default — no mouse.

Enable it with:

set -g mouse on

unbind r
bind r source-file ~/.tmux.conf
set -g prefix C-s
set -g mouse on

Setting tmux status bar position #

Move the status bar to the top to avoid confusion with Vim/Neovim status lines:

set-option -g status-position top

unbind r
bind r source-file ~/.tmux.conf
set -g prefix C-s
set -g mouse on
set-option -g status-position top

Installing Tmux Plugin Manager (TPM) #

We’ll use TPM to install plugins.

Clone it:

git clone https://github.com/tmux-plugins/tpm ~/.tmux/plugins/tpm

Add to ~/.tmux.conf:

# List of plugins
set -g @plugin 'tmux-plugins/tpm'
set -g @plugin 'tmux-plugins/tmux-sensible'
# Initialize TMUX plugin manager (keep this at the bottom)
run '~/.tmux/plugins/tpm/tpm'

Reload tmux config (Ctrl+s, r) and press Ctrl+s, I (capital I) to install plugins.

Adding colorscheme #

Add your favorite theme under # List of plugins. I use Nord:

set -g @plugin "nordtheme/tmux"

Full config so far:

unbind r
bind r source-file ~/.tmux.conf
set -g prefix C-s
set -g mouse on
set-option -g status-position top
# List of plugins
set -g @plugin 'tmux-plugins/tpm'
set -g @plugin 'tmux-plugins/tmux-sensible'
set -g @plugin "nordtheme/tmux"
# Initialize TMUX plugin manager (keep this line at the very bottom)
run '~/.tmux/plugins/tpm/tpm'

Reload (Ctrl+s, r) → Install plugins (Ctrl+s, I)

Conclusion #

Here’s your final minimal .tmux.conf:

unbind r
bind r source-file ~/.tmux.conf
set -g prefix C-s
set -g mouse on
set-option -g status-position top
# List of plugins
set -g @plugin 'tmux-plugins/tpm'
set -g @plugin 'tmux-plugins/tmux-sensible'
set -g @plugin "nordtheme/tmux"
# Initialize TMUX plugin manager (keep this line at the very bottom)
run '~/.tmux/plugins/tpm/tpm'

I hope you got your own config that fits you too.

All Tmux Plugins:
List of Tmux Plugins

Hope this blog has helped you get a starter tmux configuration — and if you liked it, please follow up on future blogs!

Vim vs Neovim

Amiitesh TSP — Sun, 05 Jan 2025 00:00:00 +0000

Introduction #

Welcome to this blog, where I’ll be plotting the differences between Vim and Neovim. I’ll also be discussing which editor to use between the two for a better workflow and a better code editing experience.

Vim and Neovim are Open Source text editors which can be tweaked for our convenience and changed according to our workflow.

Vim and Neovim are one of the best feature-rich text editors available for us today alongside Emacs. They are called mode-based or modal text editors, meaning that work is done in different modes. For example:

To enter text → Insert Mode
To select text → Visual Mode
To replace text → Replace Mode
To perform tasks like copy, paste, macros → Command Mode

What are the differences between Vim and Neovim? #

Basic Differences between the text editors: #

Extensibility:
- Vim: Uses Vimscript (a scripting language made for Vim). It has a more restricted plugin system since plugins must be written in Vimscript. Getting advanced features can be challenging.
- Neovim: A fork of Vim, built with Lua — a language with better documentation and support for plugins in multiple programming languages (function calls are interoperable). Neovim also supports asynchronous plugins, making it more performant and responsive.
UI Features:
- Vim: Primarily runs in a terminal. Even with GUIs like GVim, UI features are limited.
- Neovim: Designed to support external user interfaces. Can run in any terminal emulator or GUI (e.g., Neovide) — offering greater flexibility and Open Source freedom.
Built-In Terminal:
- Vim: No built-in terminal → requires a separate terminal tab.
- Neovim: Comes with a built-in terminal emulator, enabling running code, interacting with REPLs, and executing commands directly in the editor.

Detailed Differences between the two text editors: #

LSP Support (Language Server Protocol):
- Vim: No built-in LSP support.
- Neovim: Excellent built-in LSP support via JSON-RPC. Enables language-specific features like code linting, autocompletion, and snippets.
Directory Structure:
- Vim: Hardcodes config location → changes must be made in a single file.
- Neovim: Follows XDG Base Directory spec → config lives in ~/.config/nvim/init.lua (cleaner and standardized).
Code Formatting:
- Vim: Code style maintained by one person → formatting philosophy is centralized.
- Neovim: Maintained by a large team of contributors → more consistent and modern formatting.
Plugin Support:
- Vim: Rich plugin ecosystem, but IDE-like features are hard due to Vimscript limitations.
- Neovim: Plugins can be written in any language. Using real programming languages makes IDE-like features much easier to implement.

Bottom Note #

Both Vim and Neovim are powerful, open-source text editors designed for customization and efficient workflows. While Vim has been a long-standing favorite for many developers, Neovim enhances the experience with modern features such as:

Asynchronous plugin support
Built-in terminal
Native LSP support
Improved extensibility via Lua

These advancements make Neovim more suitable for those seeking a flexible, IDE-like environment without sacrificing performance.

Ultimately, the choice depends on your needs — but for a more feature-rich and modern editing experience, Neovim stands out as the better option.

Zig Programming Language

Amiitesh TSP — Mon, 30 Dec 2024 00:00:00 +0000

Introduction #

Zig is a modern programming language that is meant to be the successor of C programming language. Zig is a general-purpose programming language and toolchain for maintaining robust, optimal and reusable software. There is no hidden control flow, no hidden memory allocations and no preprocessors and macros as in C.

Zig has a very important and maybe the standout feature of the language and a new approach to metaprogramming. In Zig, we can call the functions at compile time and the datatypes can be assigned at compile time and much more to it.

What Makes Zig Special #

Zig is built on three big ideas: it’s simple, it’s fast, and it gives you control. Unlike some languages that make things complicated or force rules on you, Zig keeps things clear and lets you decide what to do.

Here’s a simple Zig program that says hello:

const std = @import("std");

pub fn main() !void {
 const stdout = std.io.getStdOut().writer();
 try stdout.print("Hello, {s}!\n", .{"Zig"});
}

This code prints "Hello, Zig!" to your screen. The !void part means the program might fail, and Zig makes sure you know it. We’ll talk more about that later.

Managing Memory in Zig #

Memory is like space your program uses to store things. In Zig, you get to decide how to use that space—no automatic system does it for you. This makes your program fast and safe.

Here’s an example of making a list of numbers:

const std = @import("std");

pub fn main() !void {
 var gpa = std.heap.GeneralPurposeAllocator(.{}){};
 defer gpa.deinit(); // Cleans up when done
 const allocator = gpa.allocator();

 // Make a list of 5 numbers
 var numbers = try allocator.alloc(i32, 5);
 defer allocator.free(numbers); // Free the list later

 // Fill the list with numbers 0 to 4
 for (numbers, 0..) |*num, i| num.* = @intCast(i32, i);

 const stdout = std.io.getStdOut().writer();
 try stdout.print("List: {any}\n", .{numbers});
}

What’s happening here:

You Choose: You tell Zig how to create and free the list.
Cleanup: defer makes sure the list is deleted when you’re done.
Safety: Zig checks everything when you build the program.

This way, you avoid mistakes like losing track of memory or using it twice by accident.

Handling Problems in Zig #

Zig doesn’t hide problems—it tells you when something might go wrong and helps you fix it. It uses a special way to show if a task worked or failed.

Here’s an example of reading a file:

const std = @import("std");

pub fn readFile(allocator: std.mem.Allocator, path: []const u8) ![]u8 {
 var file = try std.fs.cwd().openFile(path, .{});
 defer file.close();
 const size = try file.getEndPos();
 const buffer = try allocator.alloc(u8, size);
 _ = try file.readAll(buffer);
 return buffer;
}

pub fn main() !void {
 var gpa = std.heap.GeneralPurposeAllocator(.{}){};
 defer gpa.deinit();
 const allocator = gpa.allocator();
 const stdout = std.io.getStdOut().writer();

 const content = readFile(allocator, "example.txt") catch |err| {
 try stdout.print("Oops! Something went wrong: {}\n", .{err});
 return;
 };
 defer allocator.free(content);

 try stdout.print("File says: {s}\n", .{content});
}

What’s going on:

Success or Fail: The ! means this might work or might not.
Try: Tries something and checks if it fails.
Catch: If it fails, this part runs to handle the problem.

This makes sure you always know what’s happening—no surprises!

Wrapping Up #

Zig is great for people who like to keep things simple and clear. It lets you control your program’s memory and warns you about problems before they ruin everything.

Here’s the full file-reading code again:

const std = @import("std");

fn readFile(allocator: std.mem.Allocator, path: []const u8) ![]u8 {
 var file = try std.fs.cwd().openFile(path, .{});
 defer file.close();
 const size = try file.getEndPos();
 const buffer = try allocator.alloc(u8, size);
 _ = try file.readAll(buffer);
 return buffer;
}

pub fn main() !void {
 var gpa = std.heap.GeneralPurposeAllocator(.{}){};
 defer gpa.deinit();
 const allocator = gpa.allocator();
 const stdout = std.io.getStdOut().writer();

 const content = readFile(allocator, "example.txt") catch |err| {
 try stdout.print("Oops! Something went wrong: {}\n", .{err});
 return;
 };
 defer allocator.free(content);

 try stdout.print("File says: {s}\n", .{content});
}

Want to learn more? Check out Zig’s home on GitHub: https://github.com/ziglang/zig

Have fun exploring Zig!

DWM Window Manager

Amiitesh TSP — Mon, 09 Dec 2024 00:00:00 +0000

Introduction #

Welcome to this blog where I will be writing about DWM (Dynamic Window Manager) which is written in C intended to reduce bloat as much as possible giving us a smooth user experience. Configuring DWM can be hard for a few, but the end result is worth it. I recently wanted to try DWM for fun and turned out it was actually a very good experience that I have switched from Hyprland to DWM permanently.

To configure DWM we have to manually edit the C source code, after the changes we save. Compile it with the make command and then finally quit DWM and log back in for the changes. If there are any errors with the source code, then DWM won’t allow you to log inside the DWM until the error is corrected. So, what I did is I would backup after every stable change I make and in case of there are any errors I would copy the backup file or manually edit them in a tty.

About DWM #

DWM is a window manager for X server made by suckless.org — a group of programmers working together to make software that “suck less”. They have made many tools like:

st (suckless terminal/simple terminal)
surf (a web browser)
and some other “core” programs for a suckless experience.

There are many layouts to manage windows like tiled, monocle, floating layout. We can switch between different layouts using keybinds dynamically according to the application that we are working with.

How are windows managed #

In tiled mode, the windows are stacked above one another as a new window is created every time. Stack in the sense not “literally” stack but the windows act stacked in the memory as in the data structure “stack”.

In monocle layout, all the windows are fullscreen and now are literally stacked above each other when they are created.

In the floating layout, it is like what we use in rest of the desktop environments and in Windows. All the newly created windows are floating.

Workspaces/Tags #

In DWM, the workspaces are called “tags”. By default, there are 10 tags but we can change them to however many we want. We can also replace them with a logo instead of just numbers.

We can switch between them with shortcut key, ALT + "tag_number". We can also change the keybinds to whatever we feel comfortable.

The red circled is what is called tags

Status Bar #

There is a status bar by default provided by DWM. We can also add our own status bar if we want with patches (I’ll cover that in the upcoming heading). The status bar is divided into three parts:

Left part for the tags
Middle part for the activity that we are doing like the window name
Right one is for custom modules that we would display by script files for everything. By default, there is nothing on the right part

There are many status bars for the left part:

slstatus
dwmblocks
dwmblocks with color support
anybar (which allows us to use any bar other than the default one provided by DWM)

Patches #

We can add many other features we require by “patching” the main source code. This is one of the most exhausting parts of DWM for people who want extra features.

The patches are mostly written by other users themselves. Patches are nothing but adding extra functionality to the source code.

When applying the patches there is 7/10 chance for a patch error to occur. The error is put into a .rej file with the changes that are to be made indicated with + and -. We have to manually edit them ourselves and compile the code. We have to add the lines that start with + and delete the line that start with -.

This is the part where most quit because it’s exhausting.

This is because the patches are not intelligent enough to make all the changes by itself. They expect some block of code to be there but when there is no code block that the patch is expecting it returns an error and as I said — after we edit the file ourselves and if there are errors in the main source code, DWM won’t allow us to get into the DWM.

Bottom Note #

There are different Window managers but I really felt that this one was peculiar and thought of writing a blog on it.

There are many window managers that are a fork of this like:

You can try and install DWM if you want from the link below:

DWM: https://dwm.suckless.org/

My Workflow

Amiitesh TSP — Mon, 25 Nov 2024 00:00:00 +0000

Introduction #

About Myself #

Welcome to this blog, in this blog I’ll be discussing about my developer workflow.

I am a college student, currently in my freshman year. I develop many open source projects and through my journey of developing projects, I have tried many tools and software to make my job easier and interesting to work on. In this blog, I will be sharing all the tools and software I use everyday ranging from Desktop to CLI Tools.

Operating System #

This is one of my most favourite part. I have used Linux since my childhood, because I was influenced by my dad that I started using Linux as he uses Linux and MacOS most of the time. I am so used to using Linux that is often annoys me when I have to use Windows here at college during labs cause I am more used to coding in terminal and terminal-based editors.

Now, for the part of the operating system, Arch Linux. I used to use Ubuntu and wanted to try out Arch Linux for fun and it turned out that I liked it. Arch Linux is more of a DIY Operating System, it gives up complete freedom over what we want to do right from the time of installation.

It has one of the most powerful package managers, pacman and AUR (Arch User Repository) package managers like yay and paru. There is almost every imaginable package or software in the AUR, so much so that anything that does not exist in the AUR can be said “uninvented”.

Arch is a very lightweight distro and can be very well suitable to be used on old hardware. Almost every desktop environment is stable on Arch and we can choose whatever we find suitable for us.

Another advantage of using Linux is that we can configure almost everything right from the kernel to the visually-pleasing DEs.

Desktop Environment #

For the desktop environment, I use two different desktop environments: River.

My primary DE is River, River is not exactly a DE but its called Window Manager, they automatically tile windows when they are created instead of manually adjusting them by ourselves.

Now, I’ll explain why and how I use River. I follow certain rules that have become a habit for me over time. I initially got this idea from one of my favorite tech YouTubers, ThePrimeagen, and his way of using window managers.

Window Managers are convenient for people who use keyboard more than the mouse like myself. Everything can be configured with keybinds right from switching panes to switching workspaces. In my config, I have 5 workspaces by default and I could switch them using “SUPER + workspace_number” (SUPER is nothing but the window key).

So, here’s how I use it: #

Workspace 1: In the first workspace, I have the text editor and the terminal I’m working running on a tmux session.
Workspace 2: In workspace 2, I have my browser open for whenever I encounter issues; I get them fixed with Stack Overflow.
Workspace 3: I usually have my entertainment setup here, because when I’m bored I would usually open up a browser, watch YT and get back to what I’m doing. (I don’t listen to songs when I’m working).
Workspace 4: I don’t usually use 4 and 5 but it depends. But, most of the times its just junk that I have in here.

So, following the above rules over time, they became ingrained in my muscle memory. Now, when I think ’editor,’ my fingers instinctively press ‘SUPER + 1,’ and when I think ‘browser,’ they press ‘SUPER + 2,’ and so on for the rest.

Terminal and Code Editor #

This is also one of the most parts of my workflow. I live in the terminal/command line (Shortly as TUI). The only time I use the GUI is for browsing the web, the rest of the time I only spend it in the terminal. So configuring a good terminal and a good terminal-based code editor is one of the most important part for people like me.

For the terminal emulator, I use ghostty.
For the code editor, I use Neovim.

Ghostty Terminal Emulator #

I use the kitty terminal with my minimal configuration like fonts, colorscheme and etc.

For the fonts, I use a global configuration with IosevkaTerm Nerd Font and for the colorscheme I use Gruvbox all over my Linux config.

Neovim Text Editor #

I use Neovim as a text editor for all purposes, from editing LaTeX documents to writing code. Neovim has a steep learning curve, but ultimately it’s incredibly useful because I rarely need to take my hands off the keyboard.

Tools and Software #

There are many CLI tools and software that makes my job done easier and faster.

Git/Github
LazyGit
Fish shell
Tmux
fzf

Git/GitHub and LazyGit #

One of the most important tool that I use everyday is Git/GitHub combined with LazyGit. I don’t store my codes or projects locally. Even if the project is uncompleted I store them on GitHub under a public or a private repo. LazyGit makes Git a easy job. Instead of wanting to have type all the commands manually, LazyGit created a TUI (Terminal User Interface) driven by keybinds. It helps view changes, stage them, write commits and push them to remote repo under just keybinds.

This is how LazyGit looks:

As you can see, viewing the changes and commits all under a same place makes us complete our job way faster.

Tmux Terminal Session and uses #

Tmux is another one of such useful tools that I use. Tmux stands for Terminal Multiplexer and is used in Unix-like operating systems. It allows to use multiple terminal sessions in the terminal window. Even if the actual terminal window closes, the tmux session runs in the background and can be accessed with the name of the session, which is helpful when we accidentally close the session without saveing the changes.

Fish Shell and fzf fuzzy finder #

The standard shell for all the Linux distros is bash. We can choose whatever shell we want after that. The most common choices for shells are bash, zsh and fish. The syntax and structure of fish is way different than what it is in zsh.

Fish is a interactive shell where we can directly interact with the terminal. For example: In bash if we type ls and hit tab it will display the files and directories but we cannot directly interact with the shell to choose, instead we have to look at the file we want and type it and hit tab to complete. Whereas, in fish we can select it directly using the keys.

With the combined use of fzf (a fuzzy finder), we can make fish shell more powerful than what it already is.

Programming Language #

For the part of programming language, I am more into Cybersecurity, Network programming, DevOps and Kernel development. So I work mostly in C, C++, Assembly (for reverse engineering), Python and bash script.

For Kernel development, I use C programming.
For embedded systems, I use C and Zig.
For systems programming, I use C, Zig and C++.

Bottom Note #

These are the tools and software that I use when I develop projects and much more. I uniformly use the Nord colorscheme.

Here are the links to everything I use: #

My Linux Configuration: https://github.com/embeddingbits/arch_dotfiles
Arch Linux: https://archlinux.org/
River DE: https://codeberg.org/
Ghostty Terminal: https://ghostty.org/
Neovim: https://neovim.io/
Custom Neovim Config: https://github.com/embeddingbits/arch_dotfiles
LazyGit: https://github.com/jesseduffield/lazygit
Tmux: https://github.com/tmux/tmux/wiki
Fish Shell: https://fishshell.com/

In the upcoming blogs, I’ll write on how to configure Tmux for a better work experience.

Why Linux is better than its other competitors

Amiitesh TSP — Sun, 17 Nov 2024 00:00:00 +0000

Did you know Linux powers 90% of the world’s supercomputers and most of the internet’s servers? But have you ever thought about using it as your daily driver?

Welcome to this blog! In this post, I’ll be discussing Linux and why it’s better to daily-drive a Linux system.

What is Linux? #

Linux is an Operating System (or more precisely, a Kernel) based on Unix-like systems, created by Linus Torvalds in 1991. It is open-source and has huge use cases in the world of technology.

A kernel is a set of rules that instructs computer hardware to follow specific protocols, acting as a bridge between hardware and software.

The Linux kernel is primarily written in C, with some parts being rewritten in Rust for improved safety and performance.

Why is it a better option to daily-drive Linux? #

Linux is a lightweight operating system that typically uses 1.5–2.5 GB of RAM, making it ideal for older laptops and PCs. In comparison, Windows consumes 5–6 GB on average.

Linux is faster than Windows by a wide margin, in nearly every situation.

Since Linux is a kernel, its source code is used to create many distributions (distros). Each distro serves general and specific purposes.

Examples of Linux Distributions #

Mint Linux – Stable and beginner-friendly.
Ubuntu – Good for both beginners and servers.
Fedora – User-friendly and cutting-edge.
Arch Linux – DIY distro for intermediate to advanced users.

There are hundreds of Linux distributions to choose from!

Security and Privacy #

Linux’s open-source nature means vulnerabilities are quickly found and patched by the community.
Proprietary systems like Windows have less transparency and may include hidden backdoors.
Due to its lower market share, malware targeting Linux is extremely rare.

Cost Efficiency #

Most popular Linux distros are completely free, unlike Windows which costs around ₹12,000 ($139). All Linux updates — whether kernel, desktop environment, or system-level — are free.

Customizability #

Linux is highly customizable compared to proprietary operating systems. You can choose from many Desktop Environments (DEs) and Window Managers (WMs) depending on your workflow.

Examples:

DEs: GNOME, KDE Plasma, XFCE, Sway
WMs: Hyprland, i3, AwesomeWM, DWM, BSPWM

Linux allows you to fully customize your workflow and make your desktop visually pleasing.

Software Availability #

Contrary to popular belief, Linux doesn’t lack software — it has more options than most think.

Package Managers by Family:

apt – Debian-based (Debian, Ubuntu, Pop!_OS, Kali)
dnf / yum – Red Hat-based (Fedora, CentOS, RHEL)
pacman – Arch-based (fast and efficient)

Open Source Alternatives:

Office Suites → OnlyOffice, LibreOffice, OpenOffice
Graphics Design → GIMP (instead of Photoshop)
Code Editors → Vim, Neovim, Emacs, Nano, VSCodium

Using Linux exposes you to the FOSS ecosystem, strengthening open-source awareness and collaboration.

Performance and Stability #

Linux is known for its performance and efficiency, largely due to minimal bloatware.

Key Advantages:

Minimal Resource Usage: Low background memory usage.
No Forced Updates: You control updates — even after 15 years, it will still work fine.

LTS Distributions and Kernels #

LTS = Long Term Support. Some Linux versions are maintained for years with guaranteed stability and updates.

Ubuntu LTS: 5 years of security support.
Debian Stable: Known for rock-solid long-term reliability.

There are also LTS kernel versions that ensure stable driver and security updates.

Enhanced Productivity and Use Cases #

Linux boosts productivity due to its speed and command-line efficiency. While it supports great GUIs, many users eventually prefer using the terminal for faster workflows.

90% of Internet servers run Linux because of its stability and scalability.
Cybersecurity professionals prefer Linux since most tools run better here.
Linux proficiency is a valuable skill during technical interviews.

Common Myths About Linux #

Myth 1: Linux is only for tech geeks #

Not true! Linux can be used for general purposes. The terminal is not mandatory — it’s just powerful. You can browse the web, use apps, and enjoy a normal desktop experience.

Beginner-friendly distros include:

Myth 2: It’s hard to install software or use browsers #

False again. Package managers make installing software much easier than Windows. And yes — you can use browsers like Chrome, Firefox, Brave, etc. just as usual.

Getting Started with Linux #

Try these beginner-friendly distros:

Linux Mint — Highly recommended
Ubuntu
Fedora

Bottom Note #

Linux is more than an operating system — it’s a philosophy of freedom, efficiency, and empowerment. With its vast software library, security, performance, and endless customization, Linux is a powerful alternative to traditional systems.

Transitioning might seem unfamiliar at first, but with its community support and intuitive interfaces, it’s an enjoyable learning journey.

By adopting Linux, you’re not just choosing an OS — you’re joining a global movement built on collaboration and innovation.

So, why not give Linux a try? You might just discover a new way of computing.

Thank You for Reading #

Golang and its Philosophy

Amiitesh TSP — Fri, 08 Nov 2024 00:00:00 +0000

Go (or Golang) is an Open Source programming language developed by Google. Go has many use cases like building Microservices, Cloud Computing, Web Applications, and creating CLI Tools.

Go is a statically typed language, and its structures and syntax resemble the C Programming Language. Due to Go’s fast startup time, low runtime overhead, and platform independence, it has become a very popular language for writing microservices and other systems. Go is also known for its concurrency, meaning it can execute multiple processes simultaneously.

Golang uses Goroutines (lightweight processes) and a collection of packages and commands for dependency management. It was designed to solve issues like slow build times, difficulty writing tools, and cross-language development.

In this blog, I’ll discuss Golang and provide resources to get started.

History of Go #

Golang was created by Google to solve their internal software engineering issues as an alternative to C++. Development began in 2007, with the goal of designing a language that was easier to use while incorporating the best features of C++, JavaScript, and Python. It was released as an Open Source project by Google in 2009, allowing community contributions.

Since then, new features have been added regularly, with a major update in 2022 introducing Generics (a major feature from Java).

Due to its fast growth and practical design, major companies such as Netflix, Microsoft, Cloudflare, Docker, Twitch, and Dropbox adopted Go in their codebases.

Philosophy of Go #

The philosophy of Go and the problems it addresses are quite interesting:

Simplicity: Go focuses on simplicity. While many languages add features that lead to bloat, Go only includes features considered useful in the long term.
Efficiency: Go is designed for speed and efficiency — evident in its strong concurrency support.
Error Handling: Go encourages explicit and reliable error handling, with built-in mechanisms in most functions.
Pragmatism: Go emphasizes practical and logical solutions to real-world problems.

Features of Go #

Standard Library: Rich collection of standard libraries ranging from math to networking.
Package Management: Easy management of user-created packages and publishing them via CLI commands.
Static Typing: Types are assigned at compile time, preventing type-related runtime errors.
Unit Test Support: Built-in unit testing to ensure code quality and parallel debugging.
Platform Independence: Compiles and runs on any hardware or operating system.
Concurrency: Through Goroutines, Go allows multiple tasks to run in parallel — one of its defining features.

Some Useful Go Commands #

`go run` #

Compiles and executes code simultaneously.

go run filename.go

`go build` #

Compiles the code and creates an executable file.

go build filename.go

`go get` #

Imports third-party libraries from repositories like GitHub.

go get github.com/libname

`go fmt` #

Automatically formats code for readability using proper indentation and line spacing.

go fmt filename.go

Unformatted File #

package main
import "fmt"

func main(){
fmt.Println("Sample Addition")
a:=5
b:=4
c:=a+b
fmt.Println(c)
}

Formatted File with `go fmt` #

package main
import "fmt"

func main() {
 fmt.Println("Sample Addition")
 a := 5
 b := 4
 c := a + b
 fmt.Println(c)
}

You can see how the command improves readability and structure.

What is Go Used For? #

Go is widely used in various domains:

Container Services: Tools like Docker and Kubernetes use Go for efficient containerization and concurrency.
Network and Cloud Services: Ideal for writing high-performance web servers and APIs (e.g., Bitcoin Lightning Network, blockchain systems).
Web Services: Go’s built-in HTTP server helps companies like Netflix build scalable backend services.
Command-line Tools: Rich libraries for building powerful CLI tools.
Microservices: Used to develop microservices such as FTP/SMTP servers — used by companies like Uber.
Data Science: Go’s concurrency and memory management make it suitable for handling large datasets efficiently.

How to Learn Go #

Go is relatively easy to learn. Some may find Goroutines, Channels, and Concurrency challenging — but these are also Go’s most powerful features.

The best features always take effort to master!

The best way to learn is through books and official documentation, not endless tutorials. Many beginners get stuck in “tutorial hell” — watching too many videos, getting confused, and eventually quitting.

Go’s official documentation is among the best of any language, offering concept-based lessons and an interactive playground.

The documentation is divided into two main parts:

A Tour of Go — covers syntax and fundamentals, from variables to concurrency.
Effective Go — teaches how to write clear, idiomatic Go code.

Official Docs #

A Tour of Go: https://go.dev/tour/welcome/1
Effective Go: https://go.dev/doc/effective_go

Recommended Book #

The best beginner-friendly book to learn Go:

Learning Go: https://www.miek.nl/go/

Thank You #

Thank you for reading this blog!