DEV Community: Kb Bohara

Create SMTP server 101

Kb Bohara — Sun, 04 May 2025 13:15:35 +0000

Setting Up a Secure SMTP/IMAP Server on Ubuntu with Postfix, OpenDKIM & Dovecot

This guide walks you through building your own mail server at mail.thekbbohara.xyz on Ubuntu. You'll configure DNS in Cloudflare, obtain TLS certificates, set up Postfix for SMTP, OpenDKIM for signing, and Dovecot for IMAP/POP3.

Prerequisites

VPS with Ubuntu (20.04+).

Domain thekbbohara.xyz, managed in Cloudflare.

Root or sudo access via SSH (ssh root@91.99.29.246).

Basic Linux command‑line familiarity.

DNS Configuration in Cloudflare

Add the following records in your Cloudflare dashboard for the zone thekbbohara.xyz. For each record, set Proxy status to DNS only (gray cloud), not orange.

A Record

`Type: A

Name: @

IPv4 address: 91.99.29.246

TTL: Auto

Proxy status: DNS only (gray cloud)`

A Record

`Type: A

Name: mail

IPv4 address: 91.99.29.246

TTL: Auto

Proxy status: DNS only (gray cloud)`

MX Record

`Type: MX

Name: @

Mail server: mail.thekbbohara.xyz

Priority: 10

TTL: Auto

Proxy status: n/a`

SPF Record

`Type: TXT

Name: @

Content: v=spf1 a:mail.thekbbohara.xyz -all

TTL: Auto

Proxy status: DNS only (gray cloud)`

DKIM Record (after key generation)

`Type: TXT

Name: default._domainkey

Content: v=DKIM1; k=rsa; p=YOUR_PUBLIC_KEY

TTL: Auto

Proxy status: DNS only (gray cloud)`

DMARC Record

`Type: TXT

Name: _dmarc

Content: v=DMARC1; p=none; rua=mailto:postmaster@thekbbohara.xyz

TTL: Auto

Proxy status: DNS only (gray cloud)`

Install & Configure Postfix

Install

sudo apt update sudo apt install -y postfix

During install, choose Internet Site, System mail name=thekbbohara.xyz.

Configure /etc/postfix/main.cf – key settings:

`myhostname = mail.thekbbohara.xyz
mydomain = thekbbohara.xyz
myorigin = $mydomain
inet_interfaces = all
mydestination = $myhostname, localhost.$mydomain, localhost
relayhost =

Milter (OpenDKIM)

smtpd_milters = inet:localhost:12345
non_smtpd_milters = $smtpd_milters

TLS (letsencrypt paths)

smtpd_tls_cert_file=/etc/letsencrypt/live/mail.thekbbohara.xyz/fullchain.pem
smtpd_tls_key_file=/etc/letsencrypt/live/mail.thekbbohara.xyz/privkey.pem
smtpd_use_tls=yes
smtpd_tls_security_level = may
smtpd_tls_session_cache_database = btree:${data_directory}/smtpd_scache
smtp_tls_session_cache_database = btree:${data_directory}/smtp_scache`

Reload

sudo systemctl reload postfix

Obtain TLS Certificates with Certbot

Open port 80

sudo ufw allow 80/tcp sudo ufw reload

Install Certbot & run

sudo apt install -y certbot sudo systemctl stop postfix sudo certbot certonly --standalone -d mail.thekbbohara.xyz --agree-tos --email postmaster@thekbbohara.xyz --non-interactive
sudo systemctl start postfix

Verify

ls /etc/letsencrypt/live/mail.thekbbohara.xyz/

cert.pem chain.pem fullchain.pem privkey.pem

Setup OpenDKIM for DKIM Signing

Install

sudo apt install -y opendkim opendkim-tools

Create user/group

sudo groupadd --system opendkim sudo useradd --system --gid opendkim --home /var/run/opendkim --shell /usr/sbin/nologin opendkim

Generate keys

sudo mkdir -p /etc/opendkim/keys/thekbbohara.xyz cd /etc/opendkim/keys/thekbbohara.xyz sudo opendkim-genkey -r -b 2048 -d thekbbohara.xyz -s default sudo chown opendkim:opendkim default.private sudo chmod 600 default.private

Publish DNS record:

cat default.txt

Copy the v=DKIM1;...p=... string into Cloudflare as TXT under default._domainkey.

Configure /etc/opendkim.conf

Domain thekbbohara.xyz KeyFile /etc/opendkim/keys/thekbbohara.xyz/default.private Selector default Socket inet:12345@localhost

Enable socket in /etc/default/opendkim:

SOCKET="inet:12345@localhost"

Restart services

sudo systemctl enable --now opendkim sudo systemctl reload postfix

Test key

opendkim-testkey -d thekbbohara.xyz -s default -vv

should report "key OK"

Enable SMTPS (Implicit TLS on Port 465)

Edit /etc/postfix/master.cf and uncomment the smtps block:

smtps inet n - n - - smtpd -o syslog_name=postfix/smtps -o smtpd_tls_wrappermode=yes -o smtpd_sasl_auth_enable=yes -o smtpd_recipient_restrictions=permit_sasl_authenticated,permit_mynetworks,reject_unauth_destination

Reload Postfix

sudo systemctl reload postfix

Open firewall

sudo ufw allow 465/tcp

Verify

sudo ss -tulpn | grep ':465'

Configure Dovecot for IMAP/POP3

Install

sudo apt install -y dovecot-imapd dovecot-pop3d dovecot-lmtpd

Mail location (/etc/dovecot/conf.d/10-mail.conf):

mail_location = maildir:~/Maildir

Authentication socket (/etc/dovecot/conf.d/10-master.conf):

service auth { unix_listener /var/spool/postfix/private/auth { mode = 0660 user = postfix group = postfix } }

SSL config (/etc/dovecot/conf.d/10-ssl.conf):

ssl = required ssl_cert = </etc/letsencrypt/live/mail.thekbbohara.xyz/fullchain.pem ssl_key = </etc/letsencrypt/live/mail.thekbbohara.xyz/privkey.pem

Enable & start

sudo systemctl enable --now dovecot

Open ports

sudo ufw allow 143/tcp # IMAP sudo ufw allow 993/tcp # IMAPS sudo ufw allow 110/tcp # POP3 sudo ufw allow 995/tcp # POP3S

Testing & Verification

SMTP STARTTLS handshake

openssl s_client -starttls smtp -connect mail.thekbbohara.xyz:25 -crlf <<< "EHLO test\r\nQUIT"

SMTPS implicit TLS

openssl s_client -connect mail.thekbbohara.xyz:465 -crlf <<< "QUIT"

Send a test email

swaks --to you@domain.com --from noreply@thekbbohara.xyz --server mail.thekbbohara.xyz --port 465 --auth LOGIN --auth-user noreply --auth-password YOUR_PASS --tls

Check mail queue

postqueue -p

Verify reception

ls ~/Maildir/new

Inspect spam score

Send to mail‑tester.com and aim for ≥10/10.

Troubleshooting

bad field count in master.cf → Ensure each service line has exactly 7 columns before options.

ECONNREFUSED on 465 → Check smtps block in master.cf, reload Postfix, open firewall.

DKIM_INVALID → Re-generate keys, republish DNS, test with opendkim-testkey.

Spam placement → PTR alignment, SPF/DKIM/DMARC, warm up IP, request delisting.

Congratulations! You’ve built a fully functional, secure, and authenticated mail server. 🎉

Types of Brand Name

Kb Bohara — Sat, 08 Mar 2025 14:40:26 +0000

1. Eponymous

Named after a person or founder.

Example: Ford Motors (named after Henry Ford), Tesla (after Nikola Tesla), Disney (after Walt Disney).

2. Descriptive

Directly describing the product, service, or characteristic.

Example: General Motors (motors), Burger King (restaurant serving burgers).

3. Acronymic

Composed of initial letters from multiple words.

Example: IBM (International Business Machines), KFC (Kentucky Fried Chicken).

4.Suggestive

Suggesting a quality or benefit indirectly.

Example: Netflix (suggests internet-based movies), Fitbit (suggests fitness tracking).

5. Associative

Evokes symbolic or emotional connections

Examples:
- Amazon (evokes vastness, diversity, and abundance).
- Nike (named after the Greek goddess of victory, suggesting triumph and excellence).
- Apple (suggests simplicity, friendliness, and innovation).

6. Non-English

Examples:
- SAMSUNG: 3 star in korean
- lego : Play well in denis
- Zappos: spanis
- hulu: from chinese proverb

7. Abstract

Invented words without intrinsic meaning

Rolex
Kodak

RTX 4090 vs RTX 5070 Ti vs RTX 5090 vs RTX 5080

Kb Bohara — Wed, 26 Feb 2025 10:54:58 +0000

Specification	RTX 4090	RTX 5070 Ti	RTX 5090	RTX 5080
Architecture	Ada Lovelace (AD102)	Blackwell (GB203)	Blackwell (GB202)	Blackwell (GB203)
Process Node	TSMC 4N (5nm)	TSMC 4N (5nm)	TSMC 4NP (4nm)	TSMC 4N (5nm)
CUDA Cores	16,384	8,960	21,760	10,752
Tensor Cores	512 (4th Gen)	280 (5th Gen)	680 (5th Gen)	336 (5th Gen)
RT Cores	128 (3rd Gen)	70 (4th Gen)	170 (4th Gen)	84 (4th Gen)
Boost Clock	2520 MHz	2452 MHz	2407 MHz	2617 MHz
Memory	24GB GDDR6X	16GB GDDR7	32GB GDDR7	16GB GDDR7
Memory Bus	384‑bit	256‑bit	512‑bit	256‑bit
Memory Speed	21 Gbps	28 Gbps	30 Gbps	30 Gbps
Bandwidth	1008 GB/s	896 GB/s	1792 GB/s	960 GB/s
TFLOPS (FP32)	82.6	43.9	104.8	~56.3
TGP	450W	300W	575W	360W
PCIe Interface	4.0 x16	5.0 x16	5.0 x16	5.0 x16
DLSS Support	DLSS 3	DLSS 4	DLSS 4	DLSS 4
Power Connectors	16‑pin (450W)	8‑pin (300W)	600W PCIe Gen5	16‑pin
Release Date	Sept 2022	Feb 2025	Jan 2025	Jan 30, 2025
MSRP	$1,599	$749	$1999	$999

How to Expose Your Local MySQL Database to a Friend Using an EC2 Reverse SSH Tunnel baby.

Kb Bohara — Tue, 25 Feb 2025 08:06:31 +0000

When you want to share your local MySQL database with a friend but don’t have a public IP, you can use an EC2 instance as an intermediary. In this guide, I’ll walk you through how to set up a reverse SSH tunnel from your local machine (running MySQL) to your EC2 instance so your friend can access your database securely.

Prerequisites

Before you begin, make sure you have:

A Local Machine Running MySQL:
Your local machine should have MySQL running (default port 3306).
An AWS EC2 Instance:
The EC2 instance must have a public IP address. You’ll use this server to act as the gateway for your tunnel.
SSH Access:
You should be able to SSH into your EC2 instance from your local machine. Make sure your SSH keys are properly configured.
Basic Terminal and SSH Knowledge:
Familiarity with command-line operations and SSH is required.

Step 1: Prepare Your EC2 Instance

1.1. Configure the Security Group

Log in to your AWS Management Console and navigate to your EC2 instance’s security group. Edit the inbound rules to allow traffic on a port that will be used for tunneling (e.g., port 3307).

Protocol: TCP
Port Range: 3307
Source: (Limit access to your friend’s IP or a safe range)

1.2. Enable Gateway Ports

By default, the SSH daemon on your EC2 instance might not allow remote hosts to connect to forwarded ports. To change this:

SSH into your EC2 instance.
Open the SSH configuration file:

sudo nano /etc/ssh/sshd_config

Find and update (or add) the following line:

GatewayPorts yes

Save the file and restart SSH:

sudo systemctl restart sshd

This change allows the tunnel to accept connections from any host.

Step 2: Establish the Reverse SSH Tunnel from Your Local Machine

On your local machine (where MySQL is running), set up a reverse SSH tunnel to forward a port on your EC2 instance to your local MySQL port.

Run this command from your local terminal:

ssh -R 3307:localhost:3306 ec2-user@<EC2_PUBLIC_IP>

-R 3307:localhost:3306: This instructs SSH to forward port 3307 on the EC2 instance to port 3306 on your local machine.
ec2-user@<EC2_PUBLIC_IP>: Replace with your EC2 instance’s public IP address and adjust ec2-user if your EC2 instance uses a different default username.

Once the command runs successfully, any connection to EC2_PUBLIC_IP on port 3307 will be forwarded to your local MySQL instance.

Tips for Persistence
To keep the tunnel alive even if the connection drops, consider using autossh. This tool automatically restarts your SSH session if it disconnects.

Step 3: Connect to MySQL Remotely

Now, share these connection details with your friend:

Host:
Port: 3307
MySQL Credentials: Your MySQL username and password Your friend can now use any MySQL client (e.g., MySQL Workbench, command-line client) to connect using the above parameters. The traffic will be tunneled from the EC2 instance to your local machine securely.

For example, using the MySQL command-line client:

mysql -h <EC2_PUBLIC_IP> -P 3307 -u your_mysql_user -p

Security Considerations

Use Strong Credentials:
Ensure that your MySQL user has a strong password and only the required privileges.
Limit Access:
Restrict the allowed IP addresses in your EC2 security group to trusted sources.
Monitor Activity:
Regularly check logs on both your EC2 instance and MySQL server to ensure there’s no unauthorized access.

Nextjs and next auth middleware baby.

Kb Bohara — Sun, 23 Feb 2025 13:16:49 +0000

import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';
import { getToken } from 'next-auth/jwt';

export async function middleware(request: NextRequest) {
  const token = await getToken({ req: request, secret: process.env.NEXT_AUTH_SECRET });
  const { pathname } = request.nextUrl;

  // If the user is logged in and they try to access /signin , /, redirect them away.
  const unAuthorizedRouteOnly = ["/signin", "/"]
  if (token && unAuthorizedRouteOnly.includes(pathname)) {
    return NextResponse.redirect(new URL('/dashboard', request.url));
  }

  // If no token is found and they are not already on /signin or /, redirect to /signin.
  if (!token && !unAuthorizedRouteOnly.includes(pathname)) {
    const signInUrl = new URL('/signin', request.url);
    signInUrl.searchParams.set('callbackUrl', request.url);
    return NextResponse.redirect(signInUrl);
  }

  // Allow the request to proceed if none of the above conditions are met.
  return NextResponse.next();
}

export const config = {
  matcher: ['/((?!api|_next/static|_next/image|favicon.ico).*)'],
};

Custom socket.io server.ts in nextjs baby.

Kb Bohara — Wed, 19 Feb 2025 08:49:16 +0000

Create a server.ts file in root dir of your nextjs project. vim server.ts

import { createServer } from 'http'
import { parse } from 'url'
import next from 'next'

const port = parseInt(process.env.PORT || '3000', 10)
const dev = process.env.NODE_ENV !== 'production'
const app = next({ dev })
const handle = app.getRequestHandler()

app.prepare().then(() => {
  const httpServer = createServer((req, res) => {
    const parsedUrl = parse(req.url!, true)
    handle(req, res, parsedUrl)
  })
  httpServer.listen(port)
  console.log(
    `> Server listening at http://localhost:${port} as ${dev ? 'development' : process.env.NODE_ENV
    }`
  )
})

For socket.io.

pnpm add socket.io socket.io-client
vim server.ts

#...imports
import { Server } from "socket.io";
# const httpServer = ...}
const io = new Server(httpServer, {
    // options
  });
# socket stuff
io.on("connect", (socket) => {
    console.log("Socket connected", socket.id)
    socket.on("msg", (data) => {
      console.log(data)
      socket.emit("msg", data)
    })
  });
# ...rest

package.json

pnpm add cross-env
pnpm add ts-node -D

"type": "module",
"scripts": {
  "dev": "nodemon",
  "build": "next build && tsc --project tsconfig.server.json",
  "start": "cross-env NODE_ENV=production node dist/server.js"
},

4.tsconfig-server.json

{
  "extends": "./tsconfig.json",
  "compilerOptions": {
    "module": "es2015",
    "outDir": "dist",
    "lib": ["es2019"],
    "target": "es2019",
    "isolatedModules": false,
    "noEmit": false
  },
  "include": ["server.ts"]
}

app/page.tsx (whatever)

"use client";

import { useEffect, useRef } from "react";
import { Button } from "@/components/ui/button";
import { io, Socket } from "socket.io-client";

export default function Home() {
  const socketRef = useRef<Socket | null>(null);

  useEffect(() => {
    socketRef.current = io("ws://localhost:3000", {
      reconnectionDelayMax: 10000,
    });
    // Cleanup the socket connection on unmount
    return () => {
      socketRef.current?.disconnect();
    };
  }, []);

  const handleSend = () => {
    socketRef.current?.emit("msg", { a: "b", c: [] });
    socketRef.current?.on("msg", (data) => {
      console.log(data)
    })
  };

  return <Button onClick={handleSend}>Send</Button>
}

How to Change / Update the Kernel in Linux (systemd-boot) baby

Kb Bohara — Mon, 17 Feb 2025 14:29:04 +0000

Arch Linux provides multiple kernel options, and with systemd-boot.

1️⃣ Check Your Current Kernel

Before switching kernels, verify which kernel you're using:

uname -r
# output: 6.13.2-arch1-1
# This means you are running the **latest Arch Linux kernel**.

2️⃣ Install a New Kernel

Arch Linux offers various kernel options:

Kernel Type	Package Name	Purpose
Latest Stable Kernel	`linux`	Default, rolling release
LTS (Long-Term Support)	`linux-lts`	More stable, recommended for production
Hardened Kernel	`linux-hardened`	Security-focused
Zen Kernel	`linux-zen`	Performance optimized

Install the LTS Kernel

If you prefer a more stable setup:

sudo pacman -S linux-lts linux-lts-headers

Other Kernel Options

Hardened Kernel:

  sudo pacman -S linux-hardened

Zen Kernel:

  sudo pacman -S linux-zen

3️⃣ Verify Kernel Installation

Once installed, check if the new kernel appears in /boot:

ls /boot

You should see files like:

 EFI                            initramfs-linux-lts-fallback.img   initramfs-linux.img   vmlinuz-linux
 initramfs-linux-fallback.img   initramfs-linux-lts.img            loader                vmlinuz-linux-lts

4️⃣ Configure systemd-boot

🔹 Check Available Boot Entries

ls /boot/loader/entries/

You should see something like:

arch.conf

If arch-lts.conf is missing, you need to create it.

🔹 Create a Boot Entry for Linux-LTS

Manually create the entry file:

   sudo vim /boot/loader/entries/arch-lts.conf

Add the following content:

   title   Arch Linux LTS
   linux   /vmlinuz-linux-lts
   initrd  /initramfs-linux-lts.img
   options root=UUID=<your-root-partition-uuid> rw quiet splash

Find your root partition UUID using:

   lsblk -o NAME,MOUNTPOINTS,UUID

Save and exit esc:wq.

5️⃣ Set Default Kernel (Optional)

If you want linux-lts to be the default kernel:

Open systemd-boot loader config:

   sudo vim /boot/loader/loader.conf

Change the default entry:

   default arch-lts.conf
   timeout 3

Save the file and reboot.

6️⃣ Reboot & Select Kernel

Restart your system:

sudo reboot

At the systemd-boot menu, you should now see Arch Linux LTS listed. Select it to boot.

7️⃣ Verify the Running Kernel

After booting, check if you're using the new kernel:

uname -r

If you installed linux-lts, the output should be something like:

6.12.x-lts

8️⃣ Remove Old Kernel (Optional)

If you no longer need the old kernel:

sudo pacman -R linux

Then update systemd-boot:

bootctl update

nvm best tutorial baby

Kb Bohara — Sun, 16 Feb 2025 08:27:21 +0000

yay -S nvm # For arch

For rest of the distro idc, go figure out yourself.

nvm install <version> # install version.

nvm use <version> # use installed version.

NVIDIA RTX 4090 vs. RTX 5090: Deep Dive for AI Training

Kb Bohara — Fri, 14 Feb 2025 11:38:18 +0000

Gemini: Deep Research Summary

The rise of AI workloads has driven demand for powerful GPUs. This analysis compares NVIDIA's RTX 4090 and RTX 5090, focusing on specs, benchmarks, and real-world AI performance.

Key Differences

Feature	RTX 4090	RTX 5090
Architecture	Ada Lovelace	Blackwell
CUDA Cores	16,384	21,760
Tensor Cores	512	680
Memory Type	GDDR6X	GDDR7
Memory Capacity	24GB	32GB
Memory Bandwidth	1,008 GB/s	1,792 GB/s
Power Usage	450W	575W

The RTX 5090 outperforms the 4090 with more CUDA and Tensor Cores, faster GDDR7 memory, and improved efficiency, crucial for AI tasks.

Benchmark Comparison

Task	RTX 4090	RTX 5090
ResNet50 (FP16, Images/sec)	379	N/A
BERT Fine-tuning (Tokens/sec)	297	N/A
General AI Speedup (4K)	-	+36%
AI Image Gen (FP8)	-	+75%
AI Image Gen (FP4)	-	4x faster

The RTX 5090 delivers a 28-36% boost in ML tasks and up to 4x speedup in AI image generation.

DLSS 4 & AI Benefits

DLSS 4 introduces Multi Frame Generation (MFG), enhancing AI-driven image and video processing.

Pricing & Availability

GPU	Price	Availability
RTX 4090	~$1,600	Widely available
RTX 5090	~$1,999+	Limited stock, high demand

Verdict

RTX 5090: Best for cutting-edge AI, higher performance, but expensive & hard to find.
RTX 4090: Still powerful, more affordable, better availability.

Final Thoughts

For AI workloads, the RTX 5090 is the superior choice but comes at a premium. The RTX 4090 remains a strong alternative for those prioritizing cost and availability.

Redux toolkit basic setup baby.

Kb Bohara — Wed, 12 Feb 2025 03:11:09 +0000

You can setup your dir structure however you want.

src
├ app
│ ├ layout.js
│ │ ├ redux
│ │ │ ├ provider.js
│ │ │ └ store
│ │ │   ├ index.js
│ │ │   └slices
│ │ │      └ userSlice.js
... other dirs

slices/userSlice.js

import { createSlice } from '@reduxjs/toolkit'

const initialState = { user: {}, isLoggedIn: false }

const userSlice = createSlice({
  name: 'user',
  initialState,
  reducers: {
    setUser: (state, action) => {
      state.user = action.payload
    },
    setIsLoggedIn: (state, action) => {
      state.isLoggedIn = action.payload
    }
  },
})

export const { setUser, setIsLoggedIn } = userSlice.actions
const userReducer = userSlice.reducer
export default userReducer

store/index.js -> store.js

'use client'
import { configureStore } from "@reduxjs/toolkit"
import userReducer from "./slices/userSlice"
export const store = configureStore({
  reducer: {
    user: userReducer
  }
})

redux/provider.jsx

'use client'

const { Provider } = require("react-redux")
const { store } = require("./store")

const ReduxProvider = ({ children }) =>
  <Provider store={store}>
    {children}
  </Provider>

export default ReduxProvider

app/layout.js

//other imports
import ReduxProvider from "./redux/provider";
// ... other code
export default function RootLayout({ children }) {
  return (
    <html lang="en">
      <body className='...'>
        <ReduxProvider>
            {children}
        </ReduxProvider>
      </body>
    </html>
  );

SSH for GitHub Baby

Kb Bohara — Sun, 09 Feb 2025 09:45:59 +0000

Check for Existing SSH Keys

ls -al ~/.ssh

Generate a New SSH Key

If no keys are found, generate one:

ssh-keygen -t rsa -b 4096 -C "your_email@example.com"

Start the SSH Agent (optional)

Why?: The agent manages your keys and prevents you from entering your passphrase every time.

eval "$(ssh-agent -s)"

Add SSH Key to Agent

ssh-add ~/.ssh/id_rsa

Copy the SSH Public Key

cat ~/.ssh/id_rsa.pub

Add the Key to GitHub

Go to GitHub > Settings > SSH and GPG keys > New SSH key.
Paste the copied key.

Test SSH Connection

ssh -T git@github.com

Update Git Remote URL

git remote set-url origin git@github.com:uname/repo.git

Done! You're all set to use SSH with GitHub!

Install Arch with swapfile baby.

Kb Bohara — Thu, 06 Feb 2025 19:19:44 +0000

Hi, let's get started with our install. Download the ISO and boot it however you want.

1. Connect to WiFi

# Connect to your WiFi (replace <wifi_name> with your network)
iwctl station wlan0 connect <wifi_name>

2. Test the Connection

# Ping a website to check connectivity
ping kbbohara.com.np

3. Enable NTP

# Set network time protocol
timedatectl set-ntp true

4. Identify Your Disk

# List disks to identify your target disk (mine is /dev/sda)
lsblk

5. Partition the Disk

# Partition disk /dev/sda:
fdisk /dev/sda

# Inside fdisk, input the following:
#  g        -> Create a new GPT partition table
#  n        -> Create new partition (EFI)
#           -> Accept default partition number
#           -> Accept default first sector
#           -> Enter "+512M" for size
#  n        -> Create new partition (Linux filesystem)
#           -> Accept defaults to use the remaining space
#  w        -> Write changes and exit

6. Format the Partitions

# Format EFI partition as FAT32 and Linux partition as ext4
mkfs.fat -F32 /dev/sda1
mkfs.ext4 /dev/sda2

7. Mount the Partitions

# Mount the Linux partition and create/mount the boot directory for EFI
mount /dev/sda2 /mnt
mkdir -p /mnt/boot
mount /dev/sda1 /mnt/boot

8. Install Base Packages

# Install base system, Linux kernel, firmware, and vim
pacstrap /mnt base linux linux-firmware vim

9. Generate fstab

# Generate filesystem table
genfstab -U /mnt >> /mnt/etc/fstab
cat /mnt/etc/fstab

10. Change Root

# Enter the new system environment
arch-chroot /mnt

11. Create Swapfile

# Create and activate a 16GB swapfile
fallocate -l 16GB /swapfile
chmod 600 /swapfile
mkswap /swapfile
swapon /swapfile

12. Add Swapfile to fstab

# Open fstab and add the swapfile entry at the end
vim /etc/fstab
# Add: /swapfile none swap defaults 0 0

13. Set Timezone & Clock

# Link timezone and sync hardware clock
ln -sf /usr/share/zoneinfo/Asia/Kathmandu /etc/localtime
hwclock --systohc

14. Configure Locale

# Edit locale.gen to uncomment en_US.UTF-8 and generate locale
vim /etc/locale.gen
locale-gen
echo "LANG=en_us.UTF-8" > /etc/locale.conf

15. Set Hostname

# Set hostname to "arch"
echo "arch" > /etc/hostname

16. Configure Hosts File

# Edit /etc/hosts for proper hostname resolution
vim /etc/hosts
# Add the following:
# 127.0.0.1   localhost
# ::1         localhost
# 127.0.1.1   arch.localdomain arch

17. Set Root Password

# Set the root password
passwd

18. Install & Configure systemd-boot

# Install systemd-boot on the EFI partition
bootctl install

# Create loader configuration
vim /boot/loader/loader.conf
# Add:
# default  arch
# timeout  3
# editor   no

# Create boot entry for Arch Linux
vim /boot/loader/entries/arch.conf
# Add:
# title   Arch Linux
# linux   /vmlinuz-linux
# initrd  /initramfs-linux.img
# options root=UUID=<your-root-partition-UUID> rw
# Get UUID: blkid /dev/sda2

19. Install Additional Packages & Finalize

# Install necessary packages
pacman -S networkmanager network-manager-applet wpa_supplicant dialog os-prober mtools dosfstools base-devel linux-headers

# Exit chroot, unmount all partitions, and reboot
exit
umount -a
reboot

Post-Install Steps

Connect to WiFi with nmcli

# Use nmcli or your preferred network manager after reboot
nmcli device wifi list
nmcli device wifi connect <wifi_name> password <password>

Create a New User

# Create a new user and add to the wheel group
useradd -m -G wheel baby
passwd baby

# Allow wheel group sudo privileges
EDITOR=vim visudo
# Uncomment: %wheel ALL=(ALL) ALL

Install GPU Drivers

# For Intel:
sudo pacman -S xf86-video-intel intel-media-driver

# For AMD:
sudo pacman -S xf86-video-amdgpu

# For NVIDIA:
sudo pacman -S nvidia nvidia-utils

Audio Setup

// By default, ALSA provides basic audio support.
// For a modern audio stack, install PipeWire.
// install:
pipewire # core
pipewire-pulse # (pulse-audio replacement)
wireplumber #(pipewire session manager)
alsa-utils #(for ALSA support)
helvum #(optional, for pipewire graph GUI)

Install Hyprland and a Greeter

# Install Hyprland (Wayland compositor)
sudo pacman -S hyprland wayland wlroots xorg-xwayland polkit

# For a login greeter, consider installing ly
sudo pacman -S ly

// Done. Enjoy your Arch Linux with Hyprland!