Pratyay writes

Making Tauri Apps Packaged as AppImages Usable Again

Sat, 10 Oct 2026 15:31:00 +0000

Tauri Apps Built as Appimages are not working on modern linux distributions, like fedora, arch

Appimages are one of the nicest ways to distribute an app but not being able to run a format meant to be used on multiple os, is a bad thing. Appimage as a format is crucial for users who want to test a app and use it without the need of installing. Appimages are cool as they comes with all the required dependencies and can be operated on systems such as Windows with WSL2 and FreeBSD with the Linuxulator. Appimages are self contained in nature and requires no root access.

Gtk-Message: 21:07:08.168: Failed to load module "appmenu-gtk-module": 'gtk_module_display_init': /usr/lib64/gtk-3.0/modules/libcolorreload-gtk-module.so: undefined symbol: gtk_module_display_init
Could not create default EGL display: EGL_BAD_PARAMETER. Aborting...

** (apiark:185476): WARNING **: 21:07:33.334: atk-bridge: get_device_events_reply: unknown signature

This is a sample app image for a Tauri based rest-api client apiark.

So, I was building Drawx, the offline version of drawy, which provides data sovereignty because nothing ever leaves your machine. However, the Drawx app was not working on my machine because of some odd issues. I wanted to run the AppImage in a portable manner, but using environment variables did not help. Setting WEBKIT_DISABLE_DMABUF_RENDERER=1 or WEBKIT_DISABLE_COMPOSITING_MODE=1 either caused a crash on launch or displayed a blank screen. The issue is that the CI environment adds libraries such as libwayland-client.so inside the AppImage. This creates conflicts between the AppImage’s dependencies and the system’s libraries. The solution is to remove the duplicated dependencies and let the AppImage use the system’s libraries instead of those inside the AppImage.

How to Fix This ?

fixing missing libraries

Have composed a shell script to fix the issue. Create a file src-tauri/scripts/patch-appimage-wayland.sh and paste the script inside

#!/usr/bin/env bash
set -euo pipefail

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
REPO_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
SRC_TAURI_DIR="$REPO_ROOT/src-tauri"
TAURI_CACHE_DIR="${XDG_CACHE_HOME:-$HOME/.cache}/tauri"

# Clean up temp files on exit
TEMP_BIN=$(mktemp -d)
TEMP_EXTRACT=""
cleanup() {
  rm -rf "$TEMP_BIN"
  if [ -n "$TEMP_EXTRACT" ] && [ -d "$TEMP_EXTRACT" ]; then
    rm -rf "$TEMP_EXTRACT"
  fi
}
trap cleanup EXIT

# 1. Resolve linuxdeploy and appimage tools
LINUXDEPLOY_BIN=""
if [ -d "$TAURI_CACHE_DIR" ]; then
  cached_linuxdeploy=$(find "$TAURI_CACHE_DIR" -maxdepth 1 -name "linuxdeploy-*.AppImage" -print -quit 2>/dev/null || true)
  if [ -n "$cached_linuxdeploy" ] && [ -f "$cached_linuxdeploy" ]; then
    ln -sf "$cached_linuxdeploy" "$TEMP_BIN/linuxdeploy"
    LINUXDEPLOY_BIN="$TEMP_BIN/linuxdeploy"
  fi

  cached_plugin=$(find "$TAURI_CACHE_DIR" -maxdepth 1 -name "linuxdeploy-plugin-appimage.AppImage" -print -quit 2>/dev/null || true)
  if [ -n "$cached_plugin" ] && [ -f "$cached_plugin" ]; then
    ln -sf "$cached_plugin" "$TEMP_BIN/linuxdeploy-plugin-appimage"
  fi
fi

if [ -z "$LINUXDEPLOY_BIN" ] && command -v linuxdeploy >/dev/null 2>&1; then
  LINUXDEPLOY_BIN="$(command -v linuxdeploy)"
fi

export PATH="$TEMP_BIN:$PATH"
export APPIMAGE_EXTRACT_AND_RUN=1

# 2. Patch an AppDir in-place
patch_appdir() {
  local appdir="$1"
  echo "Patching AppDir: $appdir"

  # 1. Write self-contained Wayland compatibility hook
  mkdir -p "$appdir/apprun-hooks"
  cat << 'EOF' > "$appdir/apprun-hooks/wayland-compat.sh"
export DESKTOPINTEGRATION=1

if [ -z "${LD_PRELOAD:-}" ]; then
  for lib in \
    /usr/lib/libwayland-client.so \
    /usr/lib64/libwayland-client.so \
    /usr/lib/x86_64-linux-gnu/libwayland-client.so \
    /usr/lib/aarch64-linux-gnu/libwayland-client.so \
    /usr/lib/arm-linux-gnueabihf/libwayland-client.so; do
    if [ -f "$lib" ]; then
      export LD_PRELOAD="$lib"
      break
    fi
  done
fi
EOF
  chmod +x "$appdir/apprun-hooks/wayland-compat.sh"

  # 2. Patch AppRun so it sources the new hook before executing AppRun.wrapped
  if [ -f "$appdir/AppRun.wrapped" ]; then
    if ! grep -q "wayland-compat.sh" "$appdir/AppRun"; then
      cat << 'EOF' > "$appdir/AppRun"
#!/usr/bin/env bash
HERE="$(dirname "$(readlink -f "${0}")")"
if [ -f "$HERE/apprun-hooks/wayland-compat.sh" ]; then
  . "$HERE/apprun-hooks/wayland-compat.sh"
fi
exec "$HERE/AppRun.wrapped" "$@"
EOF
      chmod +x "$appdir/AppRun"
    fi
  elif [ -f "$appdir/AppRun" ]; then
    mv "$appdir/AppRun" "$appdir/AppRun.wrapped"
    cat << 'EOF' > "$appdir/AppRun"
#!/usr/bin/env bash
HERE="$(dirname "$(readlink -f "${0}")")"
if [ -f "$HERE/apprun-hooks/wayland-compat.sh" ]; then
  . "$HERE/apprun-hooks/wayland-compat.sh"
fi
exec "$HERE/AppRun.wrapped" "$@"
EOF
    chmod +x "$appdir/AppRun"
  fi
}

# 3. Repack AppDir into AppImage
repack_appdir() {
  local appdir="$1"
  local expected_appimage="$2"
  local bundle_dir
  bundle_dir="$(dirname "$expected_appimage")"
  local appimage_base
  appimage_base="$(basename "$expected_appimage")"

  echo "Repacking AppImage into $expected_appimage..."
  (
    cd "$bundle_dir"
    export LDAI_OUTPUT="$appimage_base"

    # Remove existing AppImage before repacking
    [ -f "$expected_appimage" ] && rm -f "$expected_appimage"

    if [ -n "$LINUXDEPLOY_BIN" ]; then
      "$LINUXDEPLOY_BIN" --appdir "$appdir" --output appimage
    elif command -v appimagetool >/dev/null 2>&1; then
      appimagetool "$appdir" "$expected_appimage"
    elif [ -x "$TEMP_BIN/linuxdeploy-plugin-appimage" ]; then
      "$TEMP_BIN/linuxdeploy-plugin-appimage" --appdir "$appdir"
    else
      echo "Error: Could not find linuxdeploy or appimagetool to repack $appdir" >&2
      exit 1
    fi
  )

  echo "Successfully repacked AppImage at $expected_appimage"
}

# 4. Process targets
if [ "${1:-}" != "" ]; then
  TARGET_PATH="$(readlink -f "$1")"
  if [ -d "$TARGET_PATH" ]; then
    patch_appdir "$TARGET_PATH"
    bundle_dir="$(dirname "$TARGET_PATH")"
    appdir_name="$(basename "$TARGET_PATH")"
    expected_appimage="${bundle_dir}/${appdir_name%.AppDir}.AppImage"
    repack_appdir "$TARGET_PATH" "$expected_appimage"
  elif [ -f "$TARGET_PATH" ]; then
    TEMP_EXTRACT=$(mktemp -d)
    echo "Extracting AppImage: $TARGET_PATH"
    (cd "$TEMP_EXTRACT" && "$TARGET_PATH" --appimage-extract >/dev/null)
    EXTRACTED_APPDIR="$TEMP_EXTRACT/squashfs-root"
    patch_appdir "$EXTRACTED_APPDIR"
    repack_appdir "$EXTRACTED_APPDIR" "$TARGET_PATH"
  else
    echo "Error: Target path not found: $TARGET_PATH" >&2
    exit 1
  fi
else
  APPDIRS=()
  while IFS= read -r -d '' dir; do
    APPDIRS+=("$dir")
  done < <(find "$SRC_TAURI_DIR/target" "$REPO_ROOT/target" -type d -name "*.AppDir" -print0 2>/dev/null || true)

  if [ "${#APPDIRS[@]}" -eq 0 ]; then
    echo "No *.AppDir found to patch. (Did you run tauri build?)"
    exit 0
  fi

  for appdir in "${APPDIRS[@]}"; do
    patch_appdir "$appdir"
    bundle_dir="$(dirname "$appdir")"
    appdir_name="$(basename "$appdir")"
    expected_appimage="${bundle_dir}/${appdir_name%.AppDir}.AppImage"
    repack_appdir "$appdir" "$expected_appimage"
  done
fi

echo "Wayland AppImage patching complete."

And Change a Little Thing in the Existing Workflow

Replace All `tauri build` Commands With `tauri build && source src-tauri/scripts/patch-appimage-wayland.sh`

if you are using vite then replace the tauri build command with tauri build && source src-tauri/scripts/patch-appimage-wayland.sh in the scripts section of package.json.

{
 "name": "drawx",
 "version": "0.8.5",
 "type": "module",
 "imports": {
  "#components/*": "./src/components/*.tsx",
  "#lib/*": "./src/lib/*.ts",
  "#hooks/*": "./src/hooks/*.ts"
 },
 "scripts": {
  "dev": "vite",
  "build": "tsc && vite build",
  "typecheck": "tsc --noEmit",
  "preview": "vite preview",
  "tauri": "tauri",
  "tauri:build": "tauri build && source src-tauri/scripts/patch-appimage-wayland.sh"
 },
 "dependencies": {
  "@astryxdesign/cli": "^0.5.4",
  "@astryxdesign/core": "^0.5.4",
  "@astryxdesign/theme-matcha": "^0.5.4",
  "@astryxdesign/theme-neutral": "^0.5.4",
  "@astryxdesign/theme-stone": "^0.5.4",
  "@astryxdesign/theme-y2k": "^0.5.4",
  "@excalidraw/excalidraw": "^0.18.1",
  "@fontsource-variable/inter": "^5.3.0",
  "@fontsource-variable/jetbrains-mono": "^5.3.0",
  "@hugeicons/core-free-icons": "^4.3.5",
  "@hugeicons/react": "^1.1.10",
  "@iconify/react": "^6.0.2",
  "@phosphor-icons/react": "^2.1.10",
  "@stylexjs/stylex": "^0.19.1",
  "@tauri-apps/api": "^2.12.1",
  "@tauri-apps/plugin-clipboard-manager": "^2.4.1",
  "@tauri-apps/plugin-dialog": "^2.8.1",
  "@tauri-apps/plugin-fs": "^2.6.0",
  "@tauri-apps/plugin-log": "^2.10.0",
  "@tauri-apps/plugin-opener": "^2.7.0",
  "@tauri-apps/plugin-process": "^2.4.0",
  "@tauri-apps/plugin-updater": "^2.13.2",
  "class-variance-authority": "^0.7.1",
  "clsx": "^2.1.1",
  "lucide-react": "^1.53.0",
  "radix-ui": "^1.7.0",
  "react": "^19.3.0",
  "react-dom": "^19.3.0",
  "react-router-dom": "^7.18.4",
  "tailwind-merge": "^3.7.0",
  "tw-animate-css": "^1.4.0"
 },
 "devDependencies": {
  "@biomejs/biome": "^2.5.15",
  "@oxlint/plugins": "1.81.0",
  "@tailwindcss/vite": "^4.3.3",
  "@tauri-apps/cli": "^2.12.1",
  "@types/node": "^26.6.4",
  "@types/react": "^19.3.0",
  "@types/react-dom": "^19.3.0",
  "@vitejs/plugin-react": "^6.1.2",
  "astryx": "^0.0.0",
  "oxfmt": "^0.72.0",
  "oxlint": "^1.87.0",
  "typescript": "~7.0.2",
  "vite": "^8.3.4",
  "zustand": "^5.0.15"
 },
 "devEngines": {
  "packageManager": {
   "name": "pnpm",
   "version": "^12.10.1",
   "onFail": "warn"
  }
 },
 "packageManager": "pnpm@12.10.1+sha512.ba40a37eb1a370d60fea8c4cf1d364c13bcccef518e98ad2bcee954f539d38da37458e58261a3fa55e06523450ea0ffff9f497b135be41f2c15c1642bacace6c",
 "trustedDependencies": [
  "@astryxdesign/cli",
  "@astryxdesign/core"
 ],
 "allowScripts": {
  "@astryxdesign/cli": true,
  "@astryxdesign/core": true
 }
}

Referred blog for initial solution of the issue.

Create Your Own Specialized Toolbox Containers for Development

Fri, 09 Oct 2026 18:35:00 +0000

I recently ran into a problem while trying to work on Homebrew on my Atomic Fedora system. I was developing a custom formula and running brew audit, but it failed because GCC & ruby was not available on the host, and i was doing brew bundle install to work reliably but had no luck.

The issue wasn’t with Homebrew itself, it was that my host environment was missing the specific dependencies needed for that workflow. I could have installed more packages globally on the host, but that would have made the system more cluttered and harder to manage.

Similarly recently I was trying to develop an app in flutter for internal use but have faced issues running that .. and things got solved when I am using a sand boxed environment. Also for agents, toolbox can be a bliss . they can run any command and there is a very low chance of breaking stuff.

Why Toolbox?

Toolbox containers are useful because they integrate well with your host system without forcing you to abandon isolation. They share your home directory and can access host resources such as the SSH agent, while still giving you a clean, disposable Linux environment for development.

That makes them especially useful when you need a project-specific toolchain but don’t want to pollute your main system. They also make it easy to define a development workflow as code instead of manually installing packages every time.

I realized that if I could create my own customized Toolbox image, I could keep the tools and dependencies I use regularly in one reusable environment.

Defining Your Own Development Environment

If you work with package maintenance, formula development, or distro-specific tooling, learning to write a Dockerfile or Containerfile is incredibly valuable. It lets you build a consistent environment that is reproducible and version able.

Here is an example of an AlmaLinux based Toolbox image for Homebrew development:

FROM quay.io/toolbx-images/almalinux-toolbox:latest

LABEL com.github.containers.toolbox="true" \
    name="alma-brew" \
    version="latest" \
    usage="This image is meant to be used with the toolbox or distrobox command" \
    summary="AlmaLinux Toolbox with GCC and Homebrew for developing brew recipes" \
    maintainer="Pratyay Mustafi <pratyaymustafi@outlook.com>"

# Copy setup scripts and package lists
COPY scripts/ /scripts/
COPY packages/ /packages/

# Run the setup scripts, then remove the build-time files
RUN chmod +x /scripts/*.sh && /scripts/*.sh
RUN rm -rf /scripts /packages

This approach makes it easy to build a container that includes exactly what you need, without modifying the host system.

I also wanted an Arch-based environment with Chaotic-AUR and paru, so I created a second image for that workflow:

FROM quay.io/toolbx/arch-toolbox:latest

LABEL com.github.containers.toolbox="true" \
    name="arch-chaotic-toolbox" \
    version="latest" \
    usage="This image is meant to be used with the toolbox or distrobox command" \
    summary="Arch Linux Toolbox with Chaotic-AUR and paru" \
    maintainer="Pratyay Mustafi <pratyaymustafi@outlook.com>"

# Copy setup scripts and package lists
COPY scripts/ /scripts/
COPY packages/ /packages/

# Run the Chaotic-AUR setup script, then remove the build-time files
RUN chmod +x /scripts/*.sh && /scripts/chaotic.sh
RUN rm -rf /scripts /packages

A Simple Layout of the file structure.

A project like this can stay clean and easy to maintain if it follows a simple layout:

.
├── .github
│   └── workflows
│       ├── build.yml
│       └── clean-runs.yml
├── .gitignore
├── ContainerFiles
│   ├── brew
│   └── chaotic
├── LICENSE
├── README.md
├── packages
│   ├── brew.packages
│   └── chaotic.packages
└── scripts
    ├── brew.sh
    └── chaotic.sh

This structure keeps each concern separated:

scripts/ contains the setup logic
packages/ contains package lists
ContainerFiles/ stores the image definitions
README.md explains how to build and use the environment

That keeps the workflow organized and easier to extend later.

Example Package List

For the Arch-based image, the package list can be as simple as this:

devel
git
paru

This is nice because package changes are declarative. If I need to add a tool, I can update the package list and rebuild the image whenever I need a new dependency or a different tool chain.

Setting up Chaotic AUR based toolbox

For Arch-based work, I also wanted a clean way to configure Chaotic AUR and install the packages I use most often. The setup script below does just that:

#!/usr/bin/env bash
set -euo pipefail

echo "==> Configuring Chaotic AUR repository..."
pacman-key --init
pacman-key --recv-key 3056513887B78AEB --keyserver keyserver.ubuntu.com
pacman-key --lsign-key 3056513887B78AEB
pacman -U --noconfirm 'https://geo-mirror.chaotic.cx/chaotic-aur/x86_64/chaotic-keyring.pkg.tar.zst'
pacman -U --noconfirm 'https://geo-mirror.chaotic.cx/chaotic-aur/x86_64/chaotic-mirrorlist.pkg.tar.zst'
sed -i 's|^Server = https://cdn-mirror.chaotic.cx|# Server = https://cdn-mirror.chaotic.cx|' /etc/pacman.d/chaotic-mirrorlist
printf '\n[chaotic-aur]\nInclude = /etc/pacman.d/chaotic-mirrorlist\n' >> /etc/pacman.conf

echo "==> Installing packages from chaotic.packages..."
grep -v '^#' /packages/chaotic.packages > /tmp/chaotic.pkglist
if [ ! -s /tmp/chaotic.pkglist ]; then
    echo "chaotic.packages is missing or empty" >&2
    exit 1
fi
xargs pacman -Syu --needed --noconfirm < /tmp/chaotic.pkglist
rm -f /tmp/chaotic.pkglist
rm -rf /var/cache/pacman/pkg/*

echo "==> Configuring toolbx permissions..."
echo "%wheel ALL=(ALL) NOPASSWD: ALL" > /etc/sudoers.d/toolbox
chmod 0440 /etc/sudoers.d/toolbox

This keeps the setup steps reproducible and easy to manage. If the Arch repository or package list changes, the update is straightforward.

Why This Workflow Works So Well

This pattern has several practical advantages:

Reproducible builds : the environment is defined in code
Portability: the same image can be built elsewhere
Isolation: dependencies stay inside the container instead of the host
Speed: no repeated manual package setup
Simplicity: the environment is easier to debug and maintain.

It is a great fit for package maintenance, Linux tooling, custom formula work, and any development workflow that depends on a specific tool chain.

Toolbox/Distrobox gives you a flexible middle ground: you get the isolation of a container without losing the convenience of working closely with your host environment.

For me, building a specialized toolbox image solved an immediate problem and gave me a more maintainable sand boxed way to work going forward. I can now create exactly the environment I need, whether that’s for Home brew development, Arch based tooling, or any other project-specific workflow.

If you work with Linux tooling, package building, or want reproducible dev setups, this is a workflow with toolbox container based development is worth adopting. Source code on GitHub.


toolbox container type	image link
brew-toolbox	quay.io/pratyay360/brew-toolbox:latest	docker.io/pratyay360/brew-toolbox:latest	ghcr.io/pratyay360/brew-toolbox:latest
chaotic-toolbox	quay.io/pratyay360/chaotic-toolbox:latest	docker.io/pratyay360/chaotic-toolbox:latest	ghcr.io/pratyay360/chaotic-toolbox:latest
android-toolbox	quay.io/pratyay360/android-toolbox:latest

Releasing tools on different channels with goreleaser

Mon, 05 Oct 2026 11:23:00 +0000

Creating a CLI tool is easy, compared to distributing it

Goreleaser makes publishing almost a cake walk, but it comes with a steep learning curve. Still, distribution is just as important as the product itself. Shipping your tool as standalone binaries isn’t enough. reaching users through established channels matters It increses your tool’s reputation and gives a free visibility. Like for macOS, there’s Homebrew, now a days many Linux distributions are promoting it, brew is backed by a large community. Similarly, Winget and Scoop are important distribution channels. Being available through these channels brings significantly more visibility and ease of use.

By the way, GoReleaser is a publishing automation tool, and it’s not exclusive to Go, one can build and distribute apps written in many languages like Go, Zig, Rust, Typescript and more.

Let’s first learn about different types of package managers before publishing there.

homebrew.

Brew is generally maintained by the community and formulas are mostly written in Ruby :).

So do you have to learn ruby to publish on homebrew?

The answer is no, you don’t. goreleaser covers everything for you.

You can create an empty GitHub repo named homebrew-tap or any other name with a homebrew- prefix. the prefix is recommended

gh repo create user1/homebrew-tap --public

brew new-tap user1/tap

brew install gh git

What is tap?

A tap is a repository with some recipes that brew needs to follow to install a tool. recipe is, in the sense, a formula to install a tool the repo user1/homebrew-tap will be reffered as user1/tap while using.

On the other side you can make a repo like user1/homebrew-cli –> user1/cli (tap).

scoop?

Scoop is a command line installer for Windows. Think of it as the Windows equivalent of Homebrew, but with its own flavor. To distribute your tool via Scoop, you’ll need to create a “bucket.” A bucket is basically Scoop’s version of a tap, a repo with the name scoop-bucket is suggested.

gh repo create user1/scoop-bucket --public
scoop bucket add bucket-name <https://github.com/user1/bucket-name> ## adding a bucket to scoop
scoop install bucket-name/your-tool ## installing your tool from the bucket

Creating a Scoop bucket is straightforward:

Winget

Now, Winget is Microsoft’s official package manager for Windows built into the operating system.

The process here is a bit different. Instead of creating a new repo you have to fork the main repo,

~~and then create a new branch for your tool~~ you don’t have to do this thing manually goreleaser handles that for you.

Winget do’s and don’ts

There are a few things to keep in mind:

one tool = one branch,

you can’t submit multiple tools in one branch as the pr is for tracking the changes of a single tool, goreleaser automates this process too.

Generally, Linux users are techy so they are more likely to install .deb and .rpm packages, as well as tools like eget, And the thing with go as a language is that it includes all the necessary C libraries in the binaries so it can be runned by just putting in $PATH on any machine.

the process generally is like you have to create/modify a file in other repo. But github-actions only gives your workflow access to that repo only

create a PAT (personal access token) with scopes read, write, releasing, files, repos, actions, action-metadata etc, and add it to your repo secrets. then you can use that token in your workflow to access other repo.

Remember you can’t create any variable with GITHUB_ prefix in the secrets, so you have to use a different name for your secret like PAT.

to create a release, you have to create a numeric tag only as winget refuses to accept alphanumeric tags.

like,

1.1.1
0.1.2-1

tags can be created using

git tag 1.1.1
git push -u origin 1.1.1

## if you use jj then 

jj new # stage changes

jj desc # describe changes

jj bookmark advance main # advance bookmark main to the new staged state.

jj tag set 1.1.1

jj git push --all #or 

jj git push --tag 1.1.1

If you have followed my previous post on doing ci with mise

then read that post first as I am going to use the same approach here. Also I am assuming you are already using mise on your machine. goreleaser is available on mise, so you can install it using mise use goreleaser@latest.

To getting started, you have to generate a goreleaser config file using goreleaser init command. It will create a .goreleaser.yml file in your repo. You can modify it according to your needs. For detailed info please refer to the official documentation.

name: build and release
on:
  push:
    tags:
      - '*'
  workflow_dispatch:

permissions:
  contents: write
  pages: write
  id-token: write

jobs:
  ci:
    runs-on: ubuntu-latest
    container:
        image: ghcr.io/jdx/mise:2026.8.16
    steps:
      - name: checkout code
        uses: actions/checkout@main
        with:
          fetch-depth: 0
      - name: Trust git directory in container
        run: git config --global --add safe.directory '*'

      - name: Install dependencies & building
        run: |
            mise deps
            mise fetch
            mise run release
        env:
          GITHUB_TOKEN: ${{ secrets.PAT }}
          MISE_EXPERIMENTAL: true

mise.toml

[tools]
go = "latest"
goreleaser = "latest"

[deps]
go = { auto = true }

[tasks]
fetch = { description = "Fetch Go module dependencies", run = "go mod download" }
testcase = { description = "Run Go testcase", run = "go run ./test/test.go" }
build = { description = "Build Go binary", run = ["mise deps", "mise run fetch", "goreleaser build --snapshot --clean"] }
test = { description = "test binary", run = ["mise deps", "mise run testcase", "mise run build"] }
testcases = { description = "Run Go test cases", run = "go test ./..." }
release = { description = "Build and release using Goreleaser", run = "goreleaser release --clean" }

So I had composed the .goreleaser.yml file for ensor it should look like this.

# yaml-language-server: $schema=https://goreleaser.com/static/schema.json
version: 2

project_name: ensor

before:
  hooks:
    - go mod tidy
    - go generate ./...

builds:
  - id: ensor
    main: .
    binary: ensor

    env:
      - CGO_ENABLED=0

    goos:
      - linux
      - windows
      - darwin
      - freebsd
      - openbsd

    goarch:
      - amd64
      - arm64
      - "386"

    ignore:
      - goos: darwin
        goarch: "386"

    flags:
      - -trimpath

    ldflags:
      - -s -w -X github.com/Pratyay360/ensor/cmd.version={{.Version}}

archives:
  - id: default
    ids:
      - ensor

    formats:
      - tar.gz

    name_template: >-
      {{ .ProjectName }}_
      {{- title .Os }}_
      {{- if eq .Arch "amd64" }}x86_64
      {{- else if eq .Arch "386" }}i386
      {{- else }}{{ .Arch }}{{ end }}
      {{- if .Arm }}v{{ .Arm }}{{ end }}

    format_overrides:
      - goos: windows
        formats:
          - zip

checksum:
  name_template: checksums.txt

changelog:
  sort: asc
  use: github

  filters:
    exclude:
      - "^docs:"
      - "^test:"

  groups:
    - title: Features
      regexp: "^feat"
      order: 0

    - title: Bug fixes
      regexp: "^fix"
      order: 1

    - title: Others
      order: 999

nfpms:
  - id: packages
    package_name: ensor
    description: "Censor secrets from your codebase"
    homepage: "https://github.com/Pratyay360/ensor"
    maintainer: "Pratyay360 <pratyaymustafi@outlook.com>"
    license: Apache-2.0

    formats:
      - deb
      - rpm
      - apk

homebrew_casks:
  - name: ensor
    homepage: "https://github.com/Pratyay360/ensor"
    description: "Censor secrets from your codebase"
    license: Apache-2.0

    binaries:
      - ensor

    generate_completions_from_executable:
      executable: ensor
      args:
        - completion
      base_name: ensor
      shell_parameter_format: cobra
      shells:
        - bash
        - zsh
        - fish

    directory: Casks
    commit_msg_template: "Brew cask update for {{ .ProjectName }} version {{ .Tag }}"

    repository:
      owner: Pratyay360
      name: homebrew-tap
      branch: main
scoops:
  - name: ensor
    homepage: "https://github.com/Pratyay360/ensor"
    description: "Censor secrets from your codebase"
    license: Apache-2.0
    commit_msg_template: "Scoop update for {{ .ProjectName }} version {{ .Tag }}"

    repository:
      owner: Pratyay360
      name: scoop-bucket
      branch: main

winget:
  - name: winget
    publisher: Pratyay360
    publisher_url: "https://github.com/Pratyay360"
    publisher_support_url: "https://github.com/Pratyay360/ensor/issues"
    package_identifier: pratyay360.ensor
    short_description: "Censor secrets from your codebase"
    description: "A unified CLI for censoring secrets from your codebase"
    license: Apache-2.0
    homepage: "https://github.com/Pratyay360/ensor"
    commit_msg_template: "{{ .PackageIdentifier }}: {{ .Tag }}"

    repository:
      owner: Pratyay360
      name: winget-pkgs
      branch: ensor   # branch name should be your tool name. for easy navigation later on.

release:
  github:
    owner: Pratyay360
    name: ensor

snapshot:
  version_template: "{{ incpatch .Version }}-next"

for other tech stack you can use make or just or mise.

I am yet to explore aur as they have stopped registration and haven’t seen any literature on conda forge so have to try this later on (maybe content for a new post), Also creating a custom coppr repo or ppa to distribute tool is tbd.

Making your own operating system with bootc

Thu, 24 Sep 2026 18:03:00 +0000

Containerizing web applications is standard practice these days, but deploying your entire operating system as a container image fundamentally changes how you interact with and manage your system. If you have been exploring the cloud-native ecosystem, you have likely heard of the bootc and ostree projects. But what exactly do they do, and why should you care?

First, let’s talk about what bootc is ?

Bootc (bootable containers) fundamentally changes how we operate our OS. Instead of just spinning up containers on top of a traditional host, you practically boot into and live inside one.

Operating systems built this way are inherently immutable, meaning you cannot write directly to the root directory (/). While this might sound restrictive at first glance, it provides massive advantages for system security, predictability, and stability.

Why an immutable, container centric OS?

A bootc based OS gives you very little headroom to break your system. It is not a drill you tried some tinkering with and suddenly the system refuses to boot. If you were still able to break it, no worries — because your system treats itself as a version-controlled system:

Atomic upgrades: Updates download in the background and unpack in parallel to the running system without interrupting your work. It is either successful or failed — no in-between state.
Instant rollbacks: If a bad update or regression ever slips through, you can instantly roll back to the previous working deployment with a simple reboot.

There are also excellent templates and tooling built around bootc, such as BlueBuild, which has a fantastic community. Because your OS is essentially a container image, you can customize it, build, and distribute it via a container registry.

Creating and Sharing Custom ISOs

Building your own container image is straightforward, but what if you want to use it on your machine? You can’t directly install a container image on a new system.

Should you be re-basing to your image after installing CoreOS? No — then why write recipes to mend your own OS?

BlueBuild gives you an option to generate your own ISO files with blue-build generate-iso, but creating that on your machine is a lot of work. So we are going to delegate that to GitHub Actions, but there remains a catch: GitHub allows release assets up to 2 GB per file, which is often too small for full OS ISOs.

Alternative storage options include object storage like S3, but there is an egress ingress cost associated, and paying money for a small hobby is a big no-no. Services like Gofile.io can be great options for storing and sharing ISO files.

Be gentle with GitHub-hosted runners — the whole process can be computationally expensive

Here is an example of my resource consumption:

GitHub Actions Workflow Run

You can check out the repository building these ISOs here: Pratyay360/blueee-os.

Recommended Base Images for Customization

If you are looking to start building your own custom bootc images, here are popular upstream base image registries:

Distribution	Base Image Registry
Fedora	fedora-ostree-desktops
AlmaLinux	almalinuxorg
CentOS Stream	centos-bootc

I have automated most of my social media accounts for free.

Sat, 19 Sep 2026 11:07:00 +0000

Recently, I have started writing blogs as a hobby to discipline myself about building a habit which is consistent

However, writing is only half the battle. As the saying goes, “If people don’t know your product exists, they can’t judge its value.”

To seriously grow, and sharing whatever I do with a wider audience is essential.

But Who Is My Target Audience?

People who are curious about technology and are accustomed to read articles.
These specific requirements make my target audience quite niche,
Which limits my choices of social media platforms even more limited.
To keep people informed about my work, I can use microblogging platforms like (X twitter/threads/blue sky/ mastodon) and LinkedIn.

But writing 10 different post on 10 different platforms is a lot of work, and I am not into that.

Also, as programmers, we tend to be “lazy” as we hate repetitive tasks,
also on the other side we love doing overengineering to solve simple problems.

Here is what I have so far:

A blog website built with a Static Site Generator (SSG).
An automatically generated RSS feed (handled automatically by the SSG).
A Cronjob to check for new posts.

First I have had planned to use some action runners on schedule like github actions, to check and trigger based on rss feed, but after I started, going through the different developer sections, I felt that’s not worth my time as someone has already done so.
So, Why reinvent the wheel when there are already some good solutions available.

Exploring existing automation solutions:

~~iftttt.com (This is free on paper only , and unusable )~~
zapier.com (Very limited free plan, but at least allows performing basic automation for free)
windmill.com (cloud: Very limited free plan, Can be self hosted) has a steep learning curve.
make.com (free plan isn’t that limited and this is the simplest solution in terms of ui).
zohoflow (free tier has good limits too but should be used along with https://www.inoreader.com/)
activepieces (good but don’t use ai copilot here)*

I will be using make.com but how to use make.com to automate my social media posting?

X (twitter) api used to be free, but that’s now paid so using official API dropped. ❌
For threads. though it’s free but automation platforms are yet to integrate it.
mastodon is free to use in most of the platforms.
same for Bluesky but it isn’t free on zapier .
Buffer is free on most of the automation platforms.

I have only found make.com to be the most suitable automation platform for free tier users and power users, as It barely restricts any core feature.

The only drawback is the limited monthly allowance of 1,000 credits. Similar to a Deterministic Finite Automaton, each step consumes one credit, regardless of whether the operation succeeds or fails.

But why am I telling you all of this and how is this free. Also will you be posting on such unsupported social media platforms manually ?

Answer is no. You don’t as we are going to use buffer.

Buffer is a social media aggregator and management platform which can manage up to 3 accounts for free

Twitter asking money hell no ❌ we are going to automate with buffer .

And make.com allows you connect up to 3 actions in a chain.

If you have used my affiliate link for make.com, they have told me that, they will be give all the users 10,000 credits for free, which their pro plan for the first month.

Buffer is generous enough to allow you to connect 3 social media accounts and manage them for free.
But you can at most post 10 posts per day on free plan which is more than enough for me.

So you can hook 3 accounts to buffer and two on make.com.

The workflow consumes 4 credits per new post. If you post too frequently, you will be limited to approximately 8 per day (4 credits × 30 days × 8 runs = 960 credits).
To avoid exhausting the free limits, it is recommended to poll executions at 3 hour intervals. Additionally, since the workflow spends most of its time polling, it only consumes one task per run.

Untitled1

Untitled

Untitled2

Untitled3

Visit make with my referral link. (for 1st month free pro)

All this automation for absolutely free and with no credit card.

Navigating around bootc and immutable/atomic distros

Thu, 17 Sep 2026 18:28:00 +0000

So, as you all know I have been a Linux user for the past 5-6 years.

And have installed os 100s of times on my system because of kernel panics or some bad driver bricking my machine, this made me an avid distro hopper.

As I have already written about the approx timeline of my distro hopping, I’m not going to repeat it here.

I personally loved KDE Plasma, and its look and feel overall. The simplicity and customization options are something I loved the most

And Fedora has the best experience with KDE Plasma.

And for the past 1 - 1.5 years, topics related to DevOps, like KVM, docker-compose, and reproducible builds, sparked curiosity in me. I got a bit deep digging into containerization, and how containerization works with namespaces and cgroups is very interesting. Though Docker has become synonymous with containers itself. But all the container runtimes follow OCI specs (Open Container Initiative) .

Podman

Podman is a daemonless container runtime. This means Podman just runs the service and vanishes from the entire process tree; unlike containerd or Docker, we don’t need to run a containerd or dockerd daemon. With Docker, running killall docker /containerd just stops all your running containers by default.

Podman is specifically impressive because of its rootless nature. One can run any number of containers as an unprivileged user and perform privileged operations within the container, similar to a fake-root environment. Btw, this is the exact same approach used in tools like rootlesskit, very similar to ports in FreeBSD, or MacPorts on Apple.

Podman doesn’t run persistently on your system, making it incredibly memory efficient.
The toolchain is practically identical to Docker; you can use podman build, podman run, podman push, etc.
Furthermore, Podman’s build tool, Buildah, is noticeably faster, making it preferable for building images quickly and efficient specially in CI/CD environments.

I probably don’t need to give a re-introduction to containers; you already know that if you’re here.
Tools like Toolbox or Distrobox just utilize this exact approach of unprivileged containers sharing the host’s user space, specifically mounting
$HOME (like /home/user/).

TBH, I personally love the philosophy behind OSTree-based operating systems: the idea of atomic updates, either successful or failed, is the exact same reason making os tree virtually unbreakable.

The concept of layering here is brilliant. The base image is immutable, and any system changes are stored in a separate layer. This makes it incredibly easy to roll back to a previous state if something gets messed up. It gives you an unbeatable safety net, and the logic is identical to how standard OCI container images are layered.

But layering packages onto the host OS isn’t always the ideal thing to do. The best approach is to use a Toolbox container for installing and running your day-to-day apps.

You can create a random Toolbox container and install any app you want. No matter how many containers you spin up, if their base image is the same, they will share that underlying image and won’t cost you extra gigabytes in storage. Sharing that base layer saves disk space and makes managing multiple environments effortless.

But aren’t containers bloated? Don’t they cost you a lot of storage space (the container tax)? The answer is both yes and no. Yes, it does cache a lot of data, but the benefits are well worth the trade-off. You get a super solid base OS while keeping the flexibility of other distros. I’ve installed paru (the Arch User Repository helper) inside a Toolbox container, installed .deb and .rpm packages, and things just work.
Distrobox or Toolbox?

I want something easy. I don’t want to type toolbox enter every time I need to run a basic app.

As I’ve mentioned, Toolbox containers generally respect the host machine a bit more (plus PAM is shared with the host), but Distrobox is undeniably convenient because of the export feature like distrobox-export --app /usr/bin/ghostty and distrobox-export --bin /usr/bin/ghostty

But what if I share something that makes Toolbox just as convenient or better ?

curl -fsSL https://github.com/Pratyay360/toolbox-export/raw/refs/heads/main/install.sh | bash

Benefits of ostree ?

libostree or Ostree is like a version control system similar to git but for the entire os. It is a crucial component of your atomic distro. Either you update your machine reboot, update completes successfully or unsuccessfully.

Even after success, ostree based os can still rollback to the previous state if anything is not working. resetting your os back to previous commit just works. It’s too hard to mess with such a

resilient system. Specially if you are using, your own recipie to build os Though it’s hard to make a faulty container image. You can identify any flaws during the image build process.

So, is everything perfect with Toolbox containers?

Networking related apps like wireshark, airmon-ng etc etc. and drivers don’t play nice; I am yet to use installed in containerd , though script evaluation is fast. Also, I’ve noticed apps installed via Distrobox often fail to honour the system theme, on the other side Toolbox respects the system theme + apps share the same secret store, in my case it’s kde wallet, and the apps I have installed in Toolbox never made me feel like they are alien to my system.

What if I don’t want the prepacked apps that comes with Fedora can i modify without pinning?

What if I want to remove Konsole and use Ghostty as my default without layering & pinning it onto my host os? I’ve actually run Ghostty installed inside an Arch Linux Toolbx as my default terminal, and it felt 100% native.

If you want absolute control on what softwares should be available on os and what not, I highly suggest making your own customized bootc image. Believe me, it is as easy as sipping a cup of tea thanks to tools like Bluebuild or OSBuild and the community around it.

I personally have 3 to 4 Toolbox images running continuously on my system, containing most of my daily apps.

One containing everything development related like ides, editors.

One containing all the media and specially CLI tools in a arch based toolbox. and another just for testing my apps. All my web browsers are downloaded via the arch toolbox.

And a Debian based toolbox just for testing my apps. and I use that ephemerally.

asciicast

See the disk usage of my system by containers above.

By the way, I am a full stack developer. And I have a graveyard of dozens of late-night ideas, abandoned projects, and half finished stuffs. You can believe me when I say the storage utilized by those 10-15 project folders easily takes up 2 to 2.5x the amount of storage that all my containers do! and that’s just from npm’s node_modules only and rust, go cache is yet to look into.

npkill

setting up redirect rules in dns

Tue, 15 Sep 2026 11:35:00 +0000

How Google and Microsoft Handle Redirects

So how do Google/Microsoft-like companies handle the redirects we see and use on a daily basis?

The most notable one I can remember was Perplexity.in → redirecting users to Gemini. From a technical standpoint, how do you redirect to a completely separate DNS zone without any control over that zone? + How are TLS certs served in such a way?

Google’s domain resolves securely; parameters remain intact; browsers show no warnings.
All common HTTP request methods, such as GET, POST, DELETE, and PUT, can function correctly through proper redirection. However, to ensure that methods other than GET (such as POST, PUT, or DELETE) are preserved during a redirect, it is necessary to use HTTP status codes 307 (Temporary Redirect) or 308 (Permanent Redirect). These status codes instruct clients to repeat the original request method and body at the new location, thereby maintaining the integrity of the operation.

So how are they served? How is HTTPS/TLS handled? How do search engines handle these redirects, and how do they know that a domain is valid or an alternate destination for the original domain?

Don’t we need to tell the server, “Hey, this is your domain,” and store an A, AAAA, or CNAME record for it? How does the server know that this is a valid domain?

So here comes the role of your DNS provider and the way they handle redirections.

Setting up redirection via a DNS provider is straightforward: you point your subdomain to a local server range Cloudflare, for example, suggests using 192.0.2.1 paired with their proxy—and then create a rule within the provider’s dashboard to redirect all requests to the target domain.

When a user visits the subdomain, the request is routed to the local server, which then triggers the redirect to the destination. Note that this must be done using a subdomain because CNAME records cannot be assigned to an apex domain. Consequently, you can only redirect subdomains, such as “www” or any other custom prefix within that zone.

Types of redirections

google suggests some codes for redirections like 30* series.

301 Moved Permanently

302 Found

303 See Other

304 Not Modified

305 Use Proxy

306 Unused

307 Temporary Redirect

308 Permanent Redirect

This ensures that search engines understand how to handle the redirection and how to process the old URL.

The approach is straightforward: configure your DNS records to point to the DNS server itself, then establish a rule with your DNS provider to redirect all requests to the target domain. Consequently, when a user visits your subdomain, the request is handled by the provider’s local server, which then issues a redirect to the target destination.

Cloudflare suggests utilizing their proxy feature to route requests through their servers, allowing them to handle redirections more effectively. I previously implemented a similar setup using freedns.afraid.org via their “web forward” feature, which successfully redirected traffic but only supported HTTP no HTTPS. In contrast, Cloudflare routes traffic through their extensive proxy network, they can issue TLS certificates and serve content securely over HTTPS.

Using chezmoi to manage dotfiles

Thu, 10 Sep 2026 20:45:00 +0000

CHEZMOI is a nice, modern, secure dotfiles manager with built-in support for handling secrets and provides a nice configurable/hackable ecosystem to tinker with. Chezmoi is a batteries-included dotfiles manager .

Unlike yadm, chezmoi doesn’t just create a git repo of your user space . Also, chezmoi supports integration with multiple password managers

Also, chezmoi is super nice with dotfiles. For example, .bashrc will be named as dot_bashrc

And if encrypted with chezmoi, it will be stored as encrypted_dot_bashrc.age

How to use age with chezmoi?

chezmoi age-keygen -o key.txt

chezmoi comes prepackaged with age. you just can run any age related command with just a chezmoi prefix

age ==> chezmoi age

and everything stays the same.

You can use chezmoi with age encryption with ssh, pgp, passphrase for recipient ..

I don’t recommend using a remote password manager to store secret values as I have faced delay in shell startup due to slow internet or dns related issues.

$callout💡 Always remember AGE_ (in caps) is your private key and should be stored safely ..and the one age.. (in small) is your public key and we will be encrypting this to this public key as an recipient $

The answer is yes and no.

If you have added a file as encrypted, Chezmoi will always keep that encrypted remotely.

chezmoi add --encrypt ~/.profile

will be stored as encrypted_dot_profile.age

BTW, you can use your GitHub account for the AGE recipient too (AGE can encrypt to SSH public keys). You can fetch the public SSH keys with:

curl https://github.com/<your username>.keys

For me, that’s

https://github.com/pratyay360.keys

This convention is followed by all the Gitforges, like GitLab, Codeberg, Source hut, etc.

If you want to use an SSH public key as the recipient in chezmoi, the general flow is:

Pick the recipient key you want to encrypt to (one line that starts with `ssh-rsa`).

Configure chezmoi/age to use it as the recipient (or export it in your shell), then add files with `–encrypt`.

you can integrate this with chezmoi config by hacking in your way.

If you generated an age keypair using:

chezmoi age-keygen -o key.txt

then:

key.txt contains your identity (private key) AGE\_(allcaps).

The corresponding age1... string inside that file is the recipient (public key).

So, I am storing my secrets in plain text in my dot files isn’t that bad and will not chezmoi mess by leaking my secrets.

answer is yes and no .

1st you need to configure a chezmoi config

something like this:-

encryption = "age"
[git]
autoCommit = true
autoPush = true
[delta]
by-side = true
numbers = true
[age]
identity = "/home/<username>/.config/chezmoi/keys.txt"
recipient = "public age key here"

If you have added a file as encrypted chezmoi will remember that and always keep that encrypted remotely.

chezmoi add --encrypt ~/.profile

will be stored as encrypted_dot_profile.age

Re-tracking a file after manual edits

If you edited a file directly (instead of using chezmoi edit), that’s fine.

If you want, chezmoi to re track the file from your home directory into the source state, run:

chezmoi re-add

This will re-add the file according to your current config (including encryption rules), so the repo still only stores the encrypted version when applicable.

Doing ci/cd the easy way.

Wed, 02 Sep 2026 19:24:00 +0000

To Begin with I Would Love to reIntroduce You to My Favourite Cli Tool Mise

Mise is a version manager for dev tools & dependencies, a task runner, an environment variables manager all in one place. Mise ensures that every collaborator is working on the same environment and each every stage is reproducible.

In an earlier post, I have discussed, managing environment variables with mise . Today I will be discussing mise’s task runner feature.

For example, if you are using mise, then you can write task recipes to execute a particular job. One mise task can have multiple child subtasks.

Like:

[tasks.install]
description = "Install JS dependencies"
run = "nub install"

[tasks.build]
description="build project"
run = "nub run build"

[tasks.start]
description="start project in production env"
run = "nub run start"

[tasks.upload]
run = "surge ./dist test69.surge.sh"
description = "deploy the built dir on surge"

Btw surge is an awesome tool that deploys your static site for free on their CDN.
you can check them out: https://surge.sh

You can see basic tasks for a simple Node.js application. But you might ask, “How do I use this in CI/CD?”

The simple answer is:

With the help of mise as a task runner and with subtasks.

[tasks.ci]
description = "production build"
run = [
    mise run install
    mise run build
]

[tasks.deploy]
description="deploy project"
run = [
    mise run ci
    mise run upload
]

Whenever someone runs mise run ci, the output always stays deterministic, which you can test on your own machine. before pushing.

And Now a Question Arises: What If?

I’ve Written Something Wrong in Tasks Then Isn’t It the Same as Writing the Entire Pipeline?

The simple answer is no. Mise never allows you to ship an invalid configuration, plus you can always debug your tasks:

mise doctor

Safety?

Mise always checks and matches check-sums (SLSA) for each package downloaded. It’s generally suggested to not use “latest”, but to pin versions for example, node@24.03 or node@24.04.

And if you want to containerize the app before running it:

mise oci run

This will spin up a container for you containing the application. (This is not suggested for chunk blobs) you can move those build artifacts to some alpine linux or distroless container.

Want to Spin up a Devcontainer ?

mise gen devcontainer --write

Mise handles most of the things for you.

It’s up to you and your creativity on, how well you write task recipes. Personally, I prefer writing atomic tasks so each task stays debug able, manageable and reproducible.

Mise can handle shell scripts as tasks too, and you can use virtually any CLI tool thanks to its nice plugin ecosystem.

Let’s Stay on Our Main Topic: CI.

In any CI platform like GitHub Actions, GitLab Pipelines, Bitbucket Pipelines, Forgejo CI, or any custom CI one thing is always common in all, your ability to run containers and running commands inside it.

Want to write a GitHub Action?

mise gen github-action —write

name: ci

on:
  workflow_dispatch:
  pull_request:
  push:

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

env:
  MISE_EXPERIMENTAL: true

jobs:
  ci:
    runs-on: ubuntu-latest
    timeout-minutes: 10
    steps:
      - uses: actions/checkout@v6
      - uses: jdx/mise-action@v3
      - run: mise run ci

But our goal isn’t to understand yaml for doing CI, but to simplify the process of writing CI pipelines. The goal is to simplify the process:

name: ci

on:
  push:
  workflow_dispatch:
  pull:

permissions:
  contents: read
  pages: write
  id-token: write

jobs:
  ci:
    runs-on: ubuntu-latest
    container:
        image: ghcr.io/jdx/mise:latest
    steps:
      - name: checkout code
        uses: actions/checkout@main

      - name: Install dependencies & building
        run: |
            mise deps
            mise run fetch
            mise run build

        env:
          SOME_ENV: ${{ secrets.SOME_ENV }}

      - name: Upload artifact
        uses: actions/upload-pages-artifact@main
        with:
          path: ./public

      - name: Deploy to GitHub Pages
        id: deployment
        uses: actions/deploy-pages@main

For you, the basic structure of the pipeline stays the same always like some kind of like a boilerplate and the quest of one tab vs 4 spaces somehow becomes irrelevant. You can now focus on writing tasks and let mise handle the rest.

The fun part is that you can now run the same on any CI platform,

each will be giving you a predictable result

See a sample workflow for Forgejo Actions:

name: CI

on:
  push:
  pull_request:
  workflow_dispatch:

env:
  MISE_EXPERIMENTAL: true

jobs:
  check:
    name: Check
    runs-on: codeberg-medium-lazy
    container:
      image: ghcr.io/jdx/mise:latest

    steps:
      - name: Check out source code
        uses: actions/checkout@v7.0.0

      - name: install dependencies
        run: |
            mise deps
            mise run deploy
        env:
          SOME_ENV: ${{ secrets.SOME_ENV }}

And the same for GitLab Actions:

image: ghcr.io/jdx/mise:latest

stages:

- build

build:
  stage: build
  script:
    - mise deps
    - mise run deploy

Using sops & age to manage environment variables

Mon, 31 Aug 2026 17:35:00 +0000

Managing env variables without a secret management mechanism specially for devs working on 10’s of different things and multiple repos. Once committed into any remote git forge it becomes a hurdle to remember which .env is of which project even after using password manager just a week later. So here comes the role of secrets management and the better way is to manage secrets in my view / the easiest way to let them live with your code. Thanks to time tested algorithms like AES256 and pgp which are not so easy to crack . Read what nist has to say about this. Tbh there is no one using something like pgp/gpg for encryption it’s more or less a paper tiger because of it’s hardness and no one barely knows how to use pgp. And to make pgp work you need the recipient to be able to decrypt the message. I doubt 99% of the people can’t even decrypt their own file after a week. So using pgp is a big no. It’s similar to loosing .env . There comes age as an encryption, it’s modern, robust easy to use and manageable asymmetric keys also age can even be used with your existing credentials like, ssh, Pgp type keys for encryption.

I am assuming that you are using some sort of *nix based operating system if not then at least use WSL(windows subsystem for Linux) to follow along.

Here we will be using a tool like sops(secret operations) .Sops is now a CNCF sandbox project and historically it’s been a project of people working at Mozilla, and later donated the project.

Sops can manage Yaml, Toml, dotenv, env.json.

But writing yaml files for config is something no one should be doing.

Why doing Gitops the hard way, also by not commiting enviornment variables you are not creating a reference so that others can collaborate on the project, SOPs is very selective at encryption it just encrypts the values not the keys.

So introducing mise my favourite tool nowadays to manage dev tools, tasks, handling environment variables, Generally it’s not recommended to pin “latest“ but i am doing so :(.

💡 To generate a mise.toml run `mise gen config` and choose tools you need from the Tui (terminal user interface)

[tools]
age = "latest"
sops = "latest"

[env]
SOPS_AGE_RECIPIENTS = "{your age recipients here}, {yet another recipient}"
_ = { file = "{ path = .env }" }

[tasks]
encrypt = "sops -e -i .env && mv .env .env.example"
decrypt = "mv .env.example .env && sops -d -i .env"

This is generally my overall workflow regarding secrets. BTW, the public key is shareable as it’s name, public,

export SOPS_AGE_KEYS="AGE_PRIVATE_KEY_HERE"

or, you can use

export SOPS_AGE_KEY_FILE="$HOME/.sops/age/keys.txt"
or 
export SOPS_AGE_KEY_FILE="$HOME/.config/sops/age/keys.txt"

keep the contents of keys.txt safe in some password manager only .

AGE supports YubiKey, ssh-agent as a helpers too.

asciicast

This is the workflow with sops configuration.

asciicast

Using mise makes the process effortless notice the difference for yourself.

BTW, Congratulations on getting started with GitOps. Happy coding!

Hello World

Sat, 22 Aug 2026 21:13:00 +0000

This is my small corner in the internet will be sharing ideas and thoughts maybe no one will be reading this but who cares. If only me and google spider reads this that’s perfectly fine. I will be writing stuff here sharing my views, opinions, and experience i gathered over the years.

From the very early age computers, electronics and internet excited me a lot.

Btw I am a Linux user for the past 5 6 years, so I can claim that I have learned a little bit about UNIX and Linux, and I think I am self entitled to share some of my experiences here Btw, now days i boot an atomic/immutable bootc based distro (which is heavily customized by me)

Most of the stuff I do is just to explore. Not afraid of trying anything new or unknown I am still equally open and curious about learning new things.

By the way, I had a childhood dream of becoming a lawyer because I tend to defend any side in any debate ~~though that usually stays within my social bubble.~~ However, with age I have realized that I am too introverted for that profession.

I have got some hot takes too, but won’t be sharing everything in one post.

So, see you later dear anon

my Linux journey so far

Mon, 16 Dec 2024 14:55:00 +0000

Beginning story

It was during covid Lockdown my school was off and I was binge watching some YouTube videos on my windows desktop sitting and suddenly I had encountered with a video about Linux and riced ui stuff I was very much amused about how good looking, minimalistic that was then I decided to switch the os of my desktop and was little bit scared about my ability to use Linux stuff that’s why i have downloaded a Ubuntu Iso as ubuntu comes 1st when searching for something about Linux and I installed virtual box and tried it out by following some youtube tutorials it was good and most of the software I used to use were Pirated Proprietary ones like photoshop, microsoft office etc. Also being good with terminal was important so that if I messed something I am capable of repairing it with some google search and some youtube videos. So I had installed ubuntu wsl on my windows machine and started learning little commands used in the unix world. Tbh, I loved spending time on terminal and Vs code at that time like crazy. I was just coding learning new stuff from youtube and sitting in front of the monitor all day after using Wsl for 1-1.5 months and using Ubuntu on Virtual Box my love for linux just grew surprisingly. My desktop at home used to have less ram so virtual Box experience was not that good for me.

Windows Subsystem for Linux - Wikipedia

(This is a visual representation of Wsl Obv copied from internet not mine as i don’t use windows any more)

Installing Linux along side Windows

So, after trying linux for 1-1.5 months on my computer(wsl) and thanks to low ram my experience with Virtualbox was not that good I had decided to install linux along side windows (dual boot). I was noob at that time at doing stuffs, installing a simple operating system was a trouble some job for me I deleted one partition from windows and installed ubuntu in that space it was not installed in the ssd even so I used to manually switch os from the bios. Even being installed on the hdd the ubuntu version was faster compared to the windows 10, I started small tinkering and exploring linux at that time that I was spending like 2/3rd of my time on linux and was booting on windows just to play some games. Once I was fully convinced about my linux skills I installed ubuntu permanently on the ssd part and also formatted my hdd drive from NTFS to ext4. Now I was officially a Linux user.

Ubuntu Desktop

(Representation of ubuntu desktop)

Distro Hopping

After installing linux permanently on my desktop there was no looking back terminal was great, I have found suitable Foss or web based alternatives to whatever I used to do. Installing/ uninstalling apps was easier than ever and after installing linux I started following multiple foss advocates and linux channels on youtube. Ricing desktop changing themes customizing is what i used to do all day . But sadly there isn’t enough option for customization on Gnome. Also I started learning about multiple distros like elementry os, manjaro, endeavour os, fedora etc etc. Some I used to love some don’t and some actually haven’t worked properly with my computer may be due to some driver compatibility or I may have broken them. The Distro I used to love the most as a beginner was PopOS it was similar to Ubuntu and it’s cosmic desktop used to be good by default. After distro hopping multiple times i realised it’s window manager and desktop environment what changes looks not the distro itself. Using PopOs for about 4 5 months I had shifted to Manjaro Kde, it was my 1st time using kde plasma and some arch derivative with kde plasma there is unlimited possibilities of customization and it’s the best desktop environment for normal users like me. Resource consumption was far lesser than gnome also loved the krunner thing which is very similar to the spotlight. I remember showing my desktop to my friends which I have modified watching Linux Experiment youtube channel, it was dope. Thanks to manjaro I got introduced to AUR(Arch user repository) It is a repository which holds shell scripts so that any one can install a app with minimum effort natively without any sandbox like flatpak or snap.

Ditching Manjaro

I personally felt some apps broke and my os broke. It was due to manjaro holds arch packages itself for testing purposes it broke apps installed through aur. Then after ditching manjaro I tried Garuda linux kde plasma edition it looked good tailored animations were great but it was resource intensive and my pc was having problems with it. So I ditched Garuda after trying for 2 3 days and installed Endeavour Os, Endeavour Os community on telegram specifically very helpful and they are very active I have communicated them with problems many times and they have solved things for me multiple time. Generally linux community is considered rude etc. After Using Endeavour os my distro hopping journey surprisingly stopped for years I have used it for continuous 2-3 years and I settled down.

Exploring Cyber Security

Have watched multiple movies, web series during lock down and I got very much motivated by Robot web series to explore cyber security. I have watched videos of hackersploit on youtube and explored my cyber security journey but most of the videos were based on concepts direct practical videos were not that much available on youtube so I tried udemy and telegram to get some videos on the topic I used my desktop to install Kali Linux and parrot Os on virtual box have also tried wifi password cracking, exploiting some old versions of wordpress etc.

Kali Linux | Penetration Testing and Ethical Hacking Linux

(visual representation of kali linux desktop)

Current Os

Have purchased a powerful hp laptop with good processor and I had installed Endeavour os on it. The laptop was working well but after kernel v 5.8 bluetooth audio used to stutter a lot and wifi 5 ghz was not stable on my laptop may be due to some driver related issue so I switched my distro once again to the distro which creator of linux Linux Torvalds himself uses Fedora. After years of using Arch based distros i realized that they were not that stable for using them on the primary machine.

I personally boot Kde plasma flavour of fedora linux it’s been 6 months and it’s running fine for me rolling release and stable flatpack updated on top of it are good. Now, I don’t distrohop any more I have found my sweet spot.

fastfetch

(Fast Fetch of my personal laptop)

Freedom

One of the biggest reasons I fell in love with Linux is the sense of freedom it offers. Unlike proprietary operating systems like Windows or macOS, Linux doesn’t limit you to a particular way of doing things. You’re free to:

Choose from hundreds of distributions that suit your needs, whether it’s a beginner-friendly distro like Ubuntu or a cutting-edge rolling release like Arch Linux.
Customize your system to work the way you want, from changing the desktop environment to tweaking even the smallest settings.
Use your computer without worrying about invasive tracking or forced updates.
This freedom extends to how you use your hardware as well. Linux runs smoothly even on older machines, letting you breathe new life into aging systems. For someone like me, who loves tinkering and optimizing, this level of control felt liberating.

Customization

The customization capabilities of Linux are what initially drew me in—and they’re what kept me hooked. With Linux, you’re not stuck with a standard, unchangeable interface. Instead, you can:

Switch between desktop environments like GNOME, KDE Plasma, or XFCE, depending on your preferences.
“Rice” your desktop to create stunning and minimalistic designs, tailoring everything from the color schemes to the window manager.
Modify the terminal to look and behave exactly how you want, using themes, plugins, and tools like Zsh or Oh My Zsh.
For me, experimenting with different configurations felt like a creative outlet. The ability to design a workspace that was both visually pleasing and incredibly functional was empowering. Unlike closed systems, Linux encouraged me to make my computer an extension of my personality.

Open-Source Philosophy

At the heart of Linux is its open-source philosophy, which fundamentally changed the way I view technology. Open-source software isn’t just about using free tools—it’s about being part of a community where collaboration and transparency take precedence.

With Linux, I realized I wasn’t just a passive consumer; I was part of a larger movement that values sharing knowledge and empowering others.
I could access the source code of the operating system and understand how it worked.
While I wasn’t skilled enough to contribute back then, knowing that I could learn from it or even modify it if needed was inspiring.
Most of the apps I used were open-source, from LibreOffice to GIMP, which helped me move away from pirated proprietary software. The open-source philosophy also made me appreciate how Linux thrives because of its community. Whether it was asking for help on forums, following FOSS advocates on YouTube, or contributing bug reports, I felt like I was part of something bigger.

ostree

ostree based distros like kinoite and bazzite are my new preference. have started with Ublue’s aurora and have loved immutable distributions. So installed kinoite on my laptop and have been using it for past 6 7 months. and it feels so complete as a distro and the way it handles updates and rollbacks is just amazing. I have rebased from kinoite base to my own recepie. Images are available at quay.io

Conclusion

Switching to Linux taught me more than just technical skills—it gave me a new perspective on freedom, creativity, and community. The ability to customize my system, use free and open-source software, and break away from proprietary restrictions made my journey rewarding. Linux isn’t just an operating system; it’s a way to embrace technology with curiosity and empowerment.

Continuation

Using linux is like a journey and the path is full of learning. I will be updating this post as my workflow changes.

Deploying nextjs app on cloudflare pages

Wed, 14 Feb 2024 14:55:00 +0000

Cloudflare pages is the best alternative when it comes to serverless platforms like Vercel or Netlify . Because cloudflare pages is virtually free and unlimited where others are limited for 100Gb bandwidth. Also there is no limitation like no commercial use on free version like Vercel.

You can compare the pricing of vercel, netlify, cloudflare pages .

To be honest though cloudflare pages is free and unlimited but SSR (Server Side Rendering) is not supported by it which is the only visible downside of using cloudflare pages all pages are statically rendered on client machine. Cloudflare pages has unlimited bandwidth and requests for free which is great for some serious apps to casual side projects. It’s better compared to paying $20 for some server side rendering and proprietary Vercel optimization.

Now let’s see how to use cloudflare pages along with NEXT.JS,

Create a next project with

npx create-next-app@latest

Terminal Next

upload project to github

github page

Open cloudflare homepage login and in dashboard go to workers and pages

cloudflare dashoard

click on create application

workers and pages

click on pages and on connect to git

create application

Link your git repository and begin setup and choose Next.Js in the framework section

deploy options

leave everything as it is if you are not using environment variables. If you are using environment variables then click on the option and add your environment variables.

Hit the Save and Deploy button.

There will be a error while opening the generated site like

Flag error

you have to copy the flag nodejs_compat and go to settings of the deployment and open functions window in it.

settings

In functions window there is a option to add compatibility flags add the copied text in both Production and Preview Options.

flags

Also change the Compatibility date to the nearest one (if not configured automatically)

compatibility date

After Doing everything thoroughly you have to re deploy the app by clicking on retry deployment.

retry deployment

After doing all the steps correctly the Next.Js app will be deployed in Cloudflare Pages link

Result

result

Feel free to comment if you are facing any problem.

Happy coding :)

Using Google Sheets as a Database

Fri, 29 Dec 2023 14:55:00 +0000

How to Use Google Sheets as a Database: A Complete Guide

Introduction :-

Now you can use Google Sheets as a basic database to make your project work and prototype your project using google’s inbuilt free api Apps Script.

Google’s spreadsheet can store text, number etc. and you can receive data in json format and use in your project in this blog I am going to show you how to store collected from customized form. One can follow this code with moderate level of coding knowledge in Javascript / React js.

1st step to start the project is to create a spreadsheet in Google Sheet

sheet home page

Click on the + icon and rename the spreadsheet name.

sheet title

here I am naming the sheet as form data

column name

I am creating 3 columns Name , Email and Message

sheet_id

I have given my sheet name as data

Now to generate a restful api for the given sheet we have to click on Extensions -> Apps Script

If you are following me step by step then your sheet should be like

spread sheet

After opening Apps Script you should change the code with

const sheets = SpreadsheetApp.openByUrl("<Enter Spreadsheet url>");
like;
// const sheets = SpreadsheetApp.openByUrl("https://docs.google.com/spreadsheets/d/1RJNF_42I9p3MTBPBM8aEVe0ZWLRzccojNNoKxGT7EHw/edit#gid=0");
const sheet = sheets.getSheetByName("data");
function doPost(e) {
  let data = e.parameter;
  sheet.appendRow([data.Name, data.Email, data.Message]);
  return ContentService.createTextOutput("Message Sent!");
}

Now click on deploy

apps script page

New Deployment -> Select Type (Web App) -> Then click Deploy

Make Sure to change access to anyone.

deploy page

Don’t forget to copy the web app link We will be using it as theapiNow open your html project and add use the following syntax

"use client"
import React from "react";
import { hydrateRoot } from 'react-dom/client';
import { useEffect, useState } from 'react';
import { FormEvent } from 'react'
import { buildCustomRoute } from "next/dist/build";
export default function Home() {
    const [isClient, setIsClient] = useState(false);
    async function Submit(e: FormEvent<HTMLFormElement>) {
        e.preventDefault();
        const formData = new FormData(e.currentTarget);
        if (!formData.get("Name") || !formData.get("Email") || !formData.get("Message")) {
            alert("Please fill all the fields");
            return;
        }
        else {
            const res = await fetch(
                // Enter your link here
                "https://script.google.com/macros/s/S2$e@vgjgK5hpeS%6C7PS^LDJ8^6J9nV3nW7%ysPsPADhwYaA!kQMngE*EP%SZD*SbS3^g/exec",
                {
                    method: "POST",
                    body: formData
                })
                .then((response) => {
                    if (response.status === 200) {
                        const formElement = document.getElementById("form") as HTMLFormElement;
                        if (formElement) {
                            formElement.reset();
                        }
                    }
                    else {
                        alert("Something went wrong");
                    }
                })
                .catch((error) => {
                    console.error("Error:", error);
                });
        }
    }
    useEffect(() => {
        setIsClient(true);
    }, []);

    return (
        <>
            <h1 className="text-center items-center justify-center p-5 mt-7 top-36 tracking-[20px] text-gray-500 text-2xl lg:text-4xl font-bold">Message Me</h1>
            <section className="text-gray-300 body-font">
                <div className="container px-5 py-24 mx-auto">
                    <div className="flex flex-wrap -m-10 justify-center whitespace-break-spaces">
                        {/* Form Start Here  */}
                        <div>
                        {isClient ? (
                            <form id="form" className="flex flex-col space-y-5" onSubmit={(e) => Submit(e)}>
                                <label className="font-bold text-lg text-white " >Name</label>
                                <input type="text" name="Name" placeholder="Enter Name" className="border rounded-lg py-3 px-3 mt-2 bg-black border-indigo-600 placeholder-white-500 text-white" />
                                <label className="font-bold text-lg text-white">Email</label>
                                <input type="email" name="Email" id="email" placeholder="example@email.com" className="border rounded-lg py-3 px-3 mt-2 bg-black border-indigo-600 placeholder-white-500 text-white" />
                                <label className="font-bold text-lg text-white " >Message</label>
                                <input type="text" name="Message" placeholder="Enter Your Message" className="border rounded-lg py-3 px-3 mt-2 bg-black border-indigo-600 placeholder-white-500 text-white" />
                                <button className="border border-indigo-600 hover:bg-indigo-600 bg-black text-white rounded-lg py-3 )font-semibold px-2" type="submit">Send Message</button>
                            </form>) :
                            (
                                <p>Form not working properly Please report to pratyaymustafi@outlook.com</p>
                            )}
                        </div>
                        {/* Form End */}
                    </div>
                </div>
            </section>

        </>
    );
}

Here I am using next.js you can use the same code with react

Here is the output of the code

message me page blank

Here I am sending a dummy message just as an example

message me page filled

As you can see the in the form is inserted into the spread sheet.

recieved response

Cons of using spreadsheet as database

Increased Dependency on google’s api
Less Scalability
Not so professional as it’s no so safe to store users data in just a spreadsheet.

Pros

Easy prototyping
Can be used to make customized survey form
Cost Effective

Have used codes of Anatu Tech partly here.

Happy coding :)

A Guide to Using Hashnode API 2.0 for Showcasing Blogs on Your Website

Wed, 01 Mar 2023 11:11:00 +0000

🤖 Update: This is an update of my previous blog on integrating Hashnode blogs into your personal website, which was based on Hashnode’s legacy API.
Hashnode will be closing the old API 1.0 in favor of the new GraphQL-based API 2.0.

In this blog, I am going to show how to fetch blogs from Hashnode’s public API 2.0. You can create cards and showcase blogs written by you on your personal portfolio website.

Why Use Hashnode API 2.0?

Hashnode API 1.0, or their legacy API, has been deprecated. Hashnode has released its new API 2.0.

How to Query and Generate JSON Using API 2.0

To query Hashnode’s API 2.0, follow the official API documentation.

In this example, we use React hooks such as useState and useEffect to manage state and fetch data from the API.

Example

Methodology

I am going to use Next.js and query the cover image, title, brief content, and blog URL for my blog (archived)

You can query a maximum of 20 blogs using Hashnode’s new API.

Hashnode allows us to query blog data in JSON format using https://gql.hashnode.com, which supports GraphQL queries. Here is a sample query:

query Publication {
  publication(host: "pratyaywrites.hashnode.dev") {
    posts(first: 20) {
      edges {
        node {
          coverImage {
            url
          }
          title
          brief
          url
        }
      }
    }
  }
}

The output after querying is:

API response

I am now going to use this JSON data on my personal portfolio site: https://pratyay.vercel.app/.

How to Integrate This GraphQL API into Next.js or React.js

I suggest following the same approach as mine:

"use client";

import React, { useEffect, useState } from "react";
import Skeleton, { SkeletonTheme } from "react-loading-skeleton";
import "react-loading-skeleton/dist/skeleton.css";
import Image from "next/image";

type Post = {
  node: {
    coverImage: {
      url: string | null;
    };
    title: string | null;
    brief: string | null;
    url: string | null;
  };
};

export default function Home() {
  // Added the API query schema to get data from Hashnode.
  const [posts, setPosts] = useState<Post[]>([]);
  const [loading, setLoading] = useState(true);

  // Change the host URL to your own publication URL.
  const query = `
    query Publication {
      publication(host: "pratyaywrites.hashnode.dev") {
        posts(first: 10) {
          edges {
            node {
              coverImage {
                url
              }
              title
              brief
              url
            }
          }
        }
      }
    }
  `;

  useEffect(() => {
    fetchPosts();
  }, []);

  const fetchPosts = async () => {
    const response = await fetch("https://gql.hashnode.com", {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
      },
      body: JSON.stringify({ query }),
    });

    const result = await response.json();
    const fetchedPosts = result.data.publication.posts.edges;

    setPosts(fetchedPosts);
    setLoading(false);
  };

  return (
    <SkeletonTheme baseColor="#202020" highlightColor="#444">
      <h1 className="mt-10 p-10 text-center text-3xl font-bold tracking-[20px] text-gray-500 lg:text-4xl">
        Blogs by Pratyay Mitra Mustafi
      </h1>

      {loading && (
        <div className="mt-10 p-10">
          <Skeleton height={500} count={1} />
        </div>
      )}

      <section className="body-font text-gray-300">
        <div className="container mx-auto px-5 py-24">
          <div className="flex flex-wrap justify-center whitespace-break-spaces">
            {posts.map((post, index) => (
              <div className="p-4 md:w-1/3" key={index}>
                <a
                  href={post.node.url || ""}
                  className="block"
                  target="_blank"
                  rel="noreferrer"
                >
                  <div className="h-full overflow-hidden rounded-lg border-2 border-gray-200 border-opacity-60 transition-all hover:scale-110">
                    {post.node.coverImage.url ? (
                      <Image
                        className="h-48 w-full object-cover object-center md:h-36 lg:h-48"
                        src={post.node.coverImage.url}
                        alt={post.node.title || ""}
                        width={350}
                        height={250}
                      />
                    ) : (
                      <Skeleton width={350} height={250} />
                    )}

                    <div className="p-6">
                      <h2 className="title-font mb-3 text-lg font-medium text-gray-300">
                        {post.node.title || ""}
                      </h2>

                      <p className="mb-3 leading-tight text-gray-400 sm:leading-4">
                        {post.node.brief || ""}
                      </p>
                    </div>
                  </div>
                </a>
              </div>
            ))}
          </div>
        </div>
      </section>
    </SkeletonTheme>
  );
}

That’s it. You can now easily display Hashnode data on your website.

You can view the output here.

Result blog

Make sure to follow Hashnode’s official documentation to make changes according to your needs.

Happy coding! 😊

Step-by-Step Guide to Setting Up a Free Self-Hosted VPN Using GitHub Education Pack

Tue, 13 Dec 2022 00:00:00 +0000

Step-by-Step Guide to Setting Up a Free Self-Hosted VPN Using GitHub Education Pack

Set up a Privacy-Friendly Free VPN We Need to Have a VPS Hosted on a Server or If You Have a Home Server You Can Forward the Ports You Get While Setting up OpenVPN in It but as Most Isp(Internet Service Providers) Uses CGNAT(Carrier-Grade NAT) It’s Hard to Get a Dedicated Public IP Address for You from the Isp They May Charge You Extra Money for Dedicated Public IP Too. So We Can Use a VPS Which Is Easy to Use and If You Take a VPS in a Foreign Nation You Can Bypass Censorship in Your Nation Too Which Is Something Extra than Self-Hosting in a Home Server.

With the GitHub education pack you are getting a trial version of AWS, azure, and digital ocean you must have to have a credit card or an international debit card to verify your payment method. here I am going to use the digital ocean in this tutorial you can use your preferred VPS providers.

steps of setting up a digital ocean for your privacy and an extra layer of security I suggest you set up a VPS with an ssh key directly don’t set it up with a password as hackers can take over your VPS by brute-forcing it.

ssh-keygen -t rsa

Type this command in your terminal to generate a public/private rsa key pair.

cat .ssh/id_rsa.pub

Type this command to see your public/private rsa key pair. now copy it and paste it here

gen ssh keys

add ssh keys

now go to market place and search here “OPENVPN”

create droplets

openvpn access server

Click here and select a server configuration for you as we are using it as VPN our traffic is going to be a bit high so we are choosing this with a high bandwidth(2TB)

pricing page

country choose

choose your preferred location from here

Now we are all done and create your customised VPS by clicking here

deploy button

Now you have to wait for some minutes to let your VPS provider here digital ocean create a VPS for you after everything done, go and log into your VPS with ssh like this

ssh root@<ipv4 address>

you will automatically get some prompt there create an OpenVPN user from there and set up a password for it after everything is done go to your browser and search

and log in there and configure your VPN according to you now log out from there and open your ipv4 address from there

open vpn login page

now just log in and download your preferred client here everything will be pre-configured according to your server

download proffered version

Just download your client and enter your password in the app which you have. Generated during setup now you are all done if you already have the Open-VPN app on your phone or laptop you can simply download the profile file from here and import it into the Open-VPN app that’s it.

already configured version

Here is how you are going to download your profile only.

In the end, using the VPN of a corporation is a risk to your privacy as they can monitor or sell your queries if they want to do so. but by this method, you own the entire infrastructure and everything is under your control means you own all your data. If you love this article make sure to get a $200 coupon for the digital ocean from my link below to show some support for getting great blogs like this.

DigitalOcean Referral Badge

Hope this blog helped you.

Happy coding :)

Project Newsy

Mon, 28 Sep 2026 05:28:00 +0000

Introducing Newsy: A Newsletter Platform Powered by GitHub Issues

Newsy is a newsletter platform inspired by projects like Utterances, Giscus, and Gitalk projects that reimagined commenting on static sites by using GitHub Issues as the backend.

Newsy takes the same idea and applies it to newsletters.

Instead of relying on a traditional email marketing service, maintaining a separate mailing list, or paying for SMTP APIs, your newsletter can live alongside your code in a GitHub repository.

Newsy is built around a simple idea: creating a newsletter should never be a complicated thing.

It aims to remove much of the overhead that comes with traditional newsletter platforms while keeping everything close to the tools developers already use.

Here’s a quick demo:

https://youtu.be/sfjo6ZVgC9w?si=RMeu6YWOWwOhn8q9

QCADesigner-E is available on appimagehub

Sun, 23 Aug 2026 11:10:00 +0000

QCADesigner-E

QCADesigner-E is an extension of QCADesigner 2.0.3, developed at the University of Bremen. It adds power-dissipation estimation for Quantum-dot Cellular Automata (QCA) circuits, based on the theoretical work of Timler, Lent, and others. The extension was presented in 2.

The power-estimation functionality is integrated as an additional simulation module based on the Coherence Vector Simulation Engine (CVSE). QCADesigner-E remains fully compatible with QCA designs created using QCADesigner 2.0.3.

QCADesigner is widely used by researchers working on QCA architectures for designing, simulating, and verifying cellular automata circuits. Its standardized environment makes it possible to model QCA logic gates and interconnects while performing timing analysis. QCADesigner-E extends this workflow by allowing researchers to estimate power dissipation and evaluate the energy characteristics of their designs.

Linux AppImage

I have repackaged QCADesigner-E as an AppImage, making it possible to run the application on a wide range of Linux distributions without requiring users to manually install its dependencies or build the software from source.

The resulting AppImage is portable and distribution-independent, providing a straightforward way to run QCADesigner-E on modern Linux systems.

https://appimage.github.io/QCADesigner-E/

https://portable-linux-apps.github.io/en/app/qcadesigner-e.html

thanks to the original authors of the application fsillt.github.io/QCADesigner-E

Pratyay writes

Making Tauri Apps Packaged as AppImages Usable Again

Tauri Apps Built as Appimages are not working on modern linux distributions, like fedora, arch

How to Fix This ?

And Change a Little Thing in the Existing Workflow

Replace All tauri build Commands With tauri build && source src-tauri/scripts/patch-appimage-wayland.sh

Create Your Own Specialized Toolbox Containers for Development

Why Toolbox?

Defining Your Own Development Environment

A Simple Layout of the file structure.

Example Package List

Setting up Chaotic AUR based toolbox

Why This Workflow Works So Well

Releasing tools on different channels with goreleaser

Creating a CLI tool is easy, compared to distributing it

So do you have to learn ruby to publish on homebrew?

What is tap?

Winget do’s and don’ts

the process generally is like you have to create/modify a file in other repo. But github-actions only gives your workflow access to that repo only

mise.toml

Making your own operating system with bootc

First, let’s talk about what bootc is ?

Why an immutable, container centric OS?

Creating and Sharing Custom ISOs

Be gentle with GitHub-hosted runners — the whole process can be computationally expensive

You can check out the repository building these ISOs here: Pratyay360/blueee-os.

Recommended Base Images for Customization

I have automated most of my social media accounts for free.

Recently, I have started writing blogs as a hobby to discipline myself about building a habit which is consistent

But Who Is My Target Audience?

Here is what I have so far:

Exploring existing automation solutions:

But why am I telling you all of this and how is this free. Also will you be posting on such unsupported social media platforms manually ?

Navigating around bootc and immutable/atomic distros

So, as you all know I have been a Linux user for the past 5-6 years.

Podman

Benefits of ostree ?

So, is everything perfect with Toolbox containers?

What if I don’t want the prepacked apps that comes with Fedora can i modify without pinning?

What if I want to remove Konsole and use Ghostty as my default without layering & pinning it onto my host os? I’ve actually run Ghostty installed inside an Arch Linux Toolbx as my default terminal, and it felt 100% native.

setting up redirect rules in dns

How Google and Microsoft Handle Redirects

So how do Google/Microsoft-like companies handle the redirects we see and use on a daily basis?

Using chezmoi to manage dotfiles

So, I am storing my secrets in plain text in my dot files isn’t that bad and will not chezmoi mess by leaking my secrets.

answer is yes and no .

Doing ci/cd the easy way.

To Begin with I Would Love to reIntroduce You to My Favourite Cli Tool Mise

And Now a Question Arises: What If?

Safety?

Using sops & age to manage environment variables

I am assuming that you are using some sort of *nix based operating system if not then at least use WSL(windows subsystem for Linux) to follow along.

Hello World

my Linux journey so far

Beginning story

Installing Linux along side Windows

Distro Hopping

Ditching Manjaro

Exploring Cyber Security

Current Os

Freedom

Customization

Open-Source Philosophy

ostree

Conclusion

Continuation

Deploying nextjs app on cloudflare pages

Create a next project with

Result

Using Google Sheets as a Database

How to Use Google Sheets as a Database: A Complete Guide

Introduction :-

1st step to start the project is to create a spreadsheet in Google Sheet

Here I am using next.js you can use the same code with react

Cons of using spreadsheet as database

Pros

A Guide to Using Hashnode API 2.0 for Showcasing Blogs on Your Website

Why Use Hashnode API 2.0?

How to Query and Generate JSON Using API 2.0

Example

Replace All `tauri build` Commands With `tauri build && source src-tauri/scripts/patch-appimage-wayland.sh`