DEV Community: Nishal K

My GitHub profile sings now, and you can add a line to the song

Nishal K — Fri, 16 Oct 2026 14:36:45 +0000

My GitHub profile has two songs on it now. One is made from my own contribution graph. The other is made by whoever stops by, and right now it's one verse long. I'd like it to be longer.

Song one: my commits as a beat

Every night a GitHub Action reads my contribution calendar and turns the last 12 months into a 90-second track. Each bar is one week of the calendar, and the lyrics come from the same numbers, so when my stats change the song changes too.

The player shows the beat grid as it plays. You can also open the remix panel, mute parts, change the tempo and share your mix as a link. There's a 45-second year trailer cut on the beat of the same song.

Song two: the visitor song

This is the one I posted about on X. You open an issue from a short form, pick a note and an instrument (everything is in A minor, so any note fits), and if you want, write up to two lyric lines of 60 characters each. That night a script adds your note to the track, puts your lines into the lyrics and credits them to your @username. The song gets a little longer every time someone joins.

You get a comment on your issue with a link to the exact second your part plays. You also get your own poster in four sizes (wide, feed, square and story), each with a QR code that starts the song at your line.

The lyrics play as a lyric video in the browser on the video page, and the same video is rendered to an MP4 and attached to a release.

// Detect dark theme var iframe = document.getElementById('tweet-2111063512143561055-49'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2111063512143561055&theme=dark" }

Who sings it

The vocals come from ACE-Step 1.5 by ACE Studio and StepFun (Apache-2.0). The workflow tries acemusic.ai first. If that fails, it runs ACE-Step on the GitHub Actions runner's CPU. If both fail, the last good take stays up, so the page never ends up with a broken song.

AI singers mumble, so every take gets checked. faster-whisper transcribes the vocals and compares them to the lyrics, and a take with missing or repeated lines gets thrown out. Then Demucs separates the vocals so I can mix them louder than the music and you can make out the words. The lyrics page says which voice sang that night's take.

Today the backup CPU voice did it, because acemusic.ai was overloaded. It took a while, but it worked, and that's why the fallback is there.

The player

The player has four looks you can switch between: Vinyl, Poster, Editorial and Sketch. The doodles around it are from Open Doodles, which are CC0.

What it costs

Nothing. It all runs on free GitHub Actions and GitHub Pages. The MP3s, MP4s and posters go into releases instead of the git history, so the repo stays small even though it renders audio and video every night.

Add your line

The song is short because hardly anyone has added to it yet. Pick a note, write a line if you feel like it, and your name goes in the credits tonight:

👉 Add a note to the visitor song

One note per person per week. Keep it kind. You can listen to the current take first, and the code is all in nishal21/nishal21.

I built a full-screen news reader that lives in the terminal

Nishal K — Fri, 31 Jul 2026 19:11:31 +0000

Installation

Linux / macOS

pip install worldnews-cli
worldnews

Windows

If pip isn't in your PATH:

py -m pip install worldnews-cli
py -m worldnews

Or:

python -m worldnews

Built With

Python
Textual
feedparser
Rich

I built a zero-config, 100% serverless portfolio generator so you never have to update yours again.

Nishal K — Mon, 13 Apr 2026 06:09:53 +0000

We all know the cycle. You spend weeks building an incredible side project, you push it to GitHub, and then... you realize you have to manually update your personal portfolio site. So, the project sits there, invisible to recruiters, and your portfolio slowly goes out of date.

I got tired of this, so I built Publicolio.

Publicolio is an open-source, zero-config generator that turns your GitHub profile into a premium, editorial-grade portfolio website instantly. No servers. No databases. No manual updates.

nishal21 / Publicolio

Publicolio is a zero-config GitHub portfolio generator. It lets you fetch a GitHub profile, select repositories, style the page with theme controls, and generate a shareable link.

Publicolio

Publicolio is a zero-configuration GitHub portfolio generator It lets you fetch profile data, curate repositories, apply visual themes, and publish a shareable portfolio URL in minutes.

Highlights

Fetches profile and repository data from GitHub.
Supports optional personal access token input in builder mode for private or owner-only repositories.
Includes 6 portfolio themes with live preview.
Exposes practical editor controls for layout, typography, card style, and accent color.
Encodes portfolio state into query parameters for deterministic sharing.
Supports optional short links through a Cloudflare Worker.
Supports short-link domain selection (auto, workers.dev, custom).
Caches builder state for returning users.
Supports Update Link flow to preserve the same short code when backend overwrite is supported.

Runtime Model

Publicolio runs in two modes:

Builder mode

Activated when user and theme query params are not present.
Renders the interactive editor (LandingBuilder) to fetch data, choose repos, style output…

View on GitHub

✨ The Visuals: Structural Themes
I didn't just want to build a tool that swapped out CSS colors. I wanted themes that fundamentally changed the layout (the DOM structure) based on the developer's vibe.

Right now, it ships with several high-end themes:

Neo-Brutalism: High contrast, harsh borders, and bold typography.

Liquid Glass: Frosted glassmorphism with overlapping translucent cards.

Aurora: Glowing animated gradients and atmospheric design.

Terminal: A high-fidelity "hacker" aesthetic with macOS-style window chrome.

You just type in your GitHub username, pick your repositories, and generate a link.

⚙️ The Architecture: Keeping it 100% Free
The most interesting challenge of this project was figuring out how to build a dynamic tool without paying for a traditional backend or database. Here is how I architected the serverless pipeline:

The Frontend (Vite + React + Tailwind v4)
The app is a strict Single Page Application (SPA) hosted for free on GitHub Pages. It fetches your pinned and recent repositories directly from the GitHub REST API right inside the browser.
Bypassing CORS & Rate Limits
If you hit GitHub's API directly from a browser, you run into strict rate limits. If you try to fetch from other platforms (like GitLab), you get hit with CORS blocks.

The Solution: I built a custom, zero-cost proxy using a Cloudflare Worker. The React app routes requests through the edge worker, which safely injects CORS headers and handles optional Personal Access Tokens (PATs) so users can fetch their private repositories safely.

The Database-less Shortener When a user selects their theme and custom repositories, that data has to be saved somewhere so the generated portfolio link works when shared. Instead of a Postgres database, I encoded the user's state directly into the URL query parameters (e.g., /?user=nishal21&theme=brutal&repos=ProjectA,ProjectB).

The Problem: Those URLs are ugly and too long for a resume.

The Solution: I spun up a second Cloudflare Worker attached to Cloudflare KV (Key-Value storage). When you deploy your portfolio, the frontend sends the long URL to the Worker, which saves it to KV and returns a sleek, random 6-character short link.

🚀 Try it out
I built this to solve my own problem, but I made it completely open-source so anyone can use it or learn from the Cloudflare architecture.

If you want to generate a portfolio for yourself in about 10 seconds, check it out!

🔗 Live Generator: [https://app.publicolio.qzz.io/]
🐙 Source Code: [https://github.com/nishal21/Publicolio]

I would love to hear your feedback on the code, the UI themes, or how you handle your own personal portfolios. Drop your generated links in the comments!

How I Built a Memory-Safe Steganography Engine in Rust to Protect Data from AI Scrapers

Nishal K — Sat, 28 Mar 2026 03:29:14 +0000

How I Built a Memory-Safe Steganography Engine in Rust to Protect Data from AI Scrapers

As AI models scale, data provenance is becoming a massive engineering challenge. Automated web scrapers are vacuuming up datasets without any regard for creator licenses or intellectual property.

I wanted to build a mathematical solution to this problem, so I architected Sigil: a zero-knowledge cryptographic vault that embeds verifiable, HMAC-SHA256 signed ownership IDs directly into the pixels of an image.

While the desktop vault (built with Tauri, Svelte, and an offline SQLite daemon) is strictly closed-source to protect the cryptographic keys, I realized that "Security by Obscurity" isn't enough. If AI companies don't know how to read the hidden IDs, they will just scrape the images anyway.

So, I open-sourced the extraction layer. Here is a deep dive into how I used Rust to build a memory-safe Least Significant Bit (LSB) steganography reader.

The Concept: LSB Steganography

Every pixel in a standard image is made of Red, Green, and Blue channels. Each channel is represented by a byte (8 bits), with values ranging from 0 to 255.

If you change the Least Significant Bit (the absolute last 1 or 0 in that byte), the color change is invisible to the human eye. But mathematically, you can use those hidden bits to store a secret payload—like a 32-byte cryptographic ID.

The Rust Implementation

To make this blazing fast and completely safe from memory leaks, I used Rust's image crate to parse the pixels. Here is the exact open-source reference implementation for extracting the payload:

use image::GenericImageView;

/// Extracts a hidden Sigil Cryptographic ID from an image's LSB layer.
pub fn verify_steganography(path: &str, expected_id_len: usize) -> Result<String, String> {
    let img = image::open(path).map_err(|e| e.to_string())?.to_rgba8();
    let mut bits = Vec::with_capacity(expected_id_len * 8);

    // 1. Extract the Least Significant Bits
    for pixel in img.pixels() {
        for channel in 0..3 { // Iterate over R, G, B
            if bits.len() < expected_id_len * 8 {
                // The bitwise AND operator isolates the final bit
                bits.push(pixel[channel] & 1);
            }
        }
    }

    // 2. Reconstruct the bytes
    let mut extracted_bytes = Vec::new();
    for chunk in bits.chunks(8) {
        if chunk.len() == 8 {
            let mut byte = 0u8;
            for (i, &bit) in chunk.iter().enumerate() {
                // Shift the bit back into its correct position
                byte |= bit << (7 - i);
            }
            extracted_bytes.push(byte);
        }
    }

    // 3. Return the Hex String
    Ok(hex::encode(extracted_bytes))
}

Breaking Down the Bitwise Math

The magic happens in two specific lines of code:

pixel[channel] & 1: This is a bitwise AND operation. By comparing the pixel's byte against 00000001, we wipe out the first 7 bits and isolate only the final bit. If the pixel is even, it returns 0. If it is odd, it returns 1. We push this bit into our Vector.
byte |= bit << (7 - i): Once we have 8 hidden bits, we need to stitch them back into a single byte. We use the left-shift operator (<<) to push the bit into the correct slot (from position 7 down to 0), and the bitwise OR operator (|=) to combine them into the final u8.

The Open Standard

By publishing this extraction logic, AI procurement teams can now integrate this exact function into their scraping pipelines. If their crawler detects a payload, they know the asset is cryptographically locked and requires an API clearance.

You can check out the full open-source extraction standard on GitHub, or visit the lightning-fast Astro-powered documentation site here:
https://nishal21.github.io/Sigil-extractor/

I’d love to hear your thoughts on the Rust implementation or LSB steganography in general!

https://github.com/nishal21/Sigil-extractor

I built an open-source, Neo-Brutalist network diagnostic tool (React + Python CLI)

Nishal K — Fri, 27 Mar 2026 13:57:31 +0000

Have you ever been frustrated by standard internet speed tests? They are often cluttered with ads, provide zero real context on what your raw speed actually means for your daily use, and force you to leave your terminal.

I wanted to fix that. So, I built SpedFind: a pro-grade, open-source network diagnostic tool. I designed it to cater to both visual users and terminal power users by building two distinct interfaces.

nishal21 / SpedFind

A highly accurate, free, and open-source internet speed test tool featuring a stunning Neo-Brutalist Cyber-HUD and a beautiful Terminal Dashboard.

🚀 SPEDFIND.

Pro-Grade Network Diagnostics & Telemetry

A highly accurate, free, and open-source internet speed test tool featuring a stunning Neo-Brutalist Cyber-HUD and a beautiful Terminal Dashboard.

✨ Features

🌐 Web Dashboard (React + Tailwind v4)

Neo-Brutalist Cyber-HUD: An immersive, high-performance UI designed for network professionals.
Live Telemetry: Real-time SVG charting of downstream and upstream data.
Advanced Diagnostics: Measures Ping, Jitter, Packet Loss, and exact Data Consumption in MB.
Identity Vectoring: Pinpoint-accurate ISP, ASN, and geographic location mapping (powered by IPinfo/MaxMind databases).
Network Grading System: Automatically evaluates your connection and assigns a grade (S, A, B, C, F) alongside use-case suitability (e.g., 8K Streaming, E-Sports).
Export to Clipboard: Instantly format and copy your network telemetry for ISP support tickets.

💻 Command-Line Interface (Python + Rich)

Terminal Dashboard: A beautifully animated rich console interface.
Real-Time Morphing: In-place UI updates without spamming your terminal.
Ookla Core Integration: Uses the global speedtest network…

View on GitHub

Here is a breakdown of how I built it and the tech stack behind it.

🌐 The Frontend: A Neo-Brutalist Web HUD

Standard dashboards can be boring. I wanted this to feel like a high-performance Cyber-HUD.

I built the web interface using React, Vite, and Tailwind CSS v4.

Live Telemetry: It features real-time SVG charting of your downstream and upstream data.
Network Grading System: Instead of just throwing a ping number at you, the app evaluates your connection and assigns a grade (S, A, B, C, F). It actually tells you if your current network can handle 8K streaming or competitive E-Sports.
Identity Vectoring: It hooks into IPinfo/MaxMind to pinpoint your ISP, ASN, and geographic location.

💻 The Backend & CLI: Python Power

For developers who want to stay in their workflow, I built a standalone command-line interface.

Real-Time Morphing: Using Python and the rich library, the terminal dashboard animates and updates in-place. It gives you all the telemetry data without spamming your console history.
FastAPI Testing Engine: To handle the payload testing and ensure complete control over the telemetry data feeding the React frontend, I built a custom stream engine using FastAPI. It uses the global Ookla network under the hood for enterprise-grade accuracy.

🚀 Try It Out

The project is 100% free and open-source under the MIT license. There are no paid API keys required to run or self-host this.

You can check out the live demo of the Web HUD here: SpedFind Live Demo

If you like building custom dev tools or just want a better way to check your network, I’d love for you to try it out. Let me know in the comments: do you prefer the Web HUD or the Terminal CLI?

I built a Carbon Footprint tracker for my code (using Tauri?!) 🍃

Nishal K — Sun, 08 Feb 2026 16:59:10 +0000

The Problem: Invisible Emissions ☁️

As developers, we are obsessed with optimization. We profile our code for Time Complexity ($O(n)$), memory leaks, and bundle size.

But there is one metric we usually ignore: Carbon Intensity.

Every time we run a heavy build, spin up a Docker container, or train a model, we draw power. Depending on where you live (and your grid's current mix of coal vs. renewables), that power has a carbon cost.

I wanted to see that cost in real-time. So, I built CarbonLint.

Meet CarbonLint 🌍

[Insert Screenshot of your Dashboard here]

CarbonLint is an open-source desktop app that monitors your development environment's energy usage and estimates the CO2 emissions of your workflow.

It helps you answer:

"How much CO2 did that last CI/CD run generate?"
"Is my local grid green right now, or should I wait to run this heavy task?"

Under the Hood 🛠️

I built this using Tauri, React, and Vite.

Wait, an Tauri app to save energy? Tauri is known for being lightweight.

Here is how I tried to balance it:

Backend: I use systeminformation and node-powershell to pull raw system metrics (CPU, Memory, Network).
Calculation: The app applies regional grid intensity factors to convert raw kWh into gCO2.
Frontend: React + Chart.js for the visualization.

The Challenge

The hardest part was getting accurate regional data. [Briefly explain how you handled the regional data/grid intensity].

Try it out (It's Open Source)

I am looking for contributors to help improve the calculation models and add support for more regions.

Repo: https://github.com/nishal21/CarbonLint
Tech: Tauri, React, TailwindCSS

If you are interested in Green Software Engineering, I’d love your feedback!

Let me know in the comments: Do you track your code's energy usage?

DEV Community: Nishal K

My GitHub profile sings now, and you can add a line to the song

Song one: my commits as a beat

Song two: the visitor song

Who sings it

The player

What it costs

Add your line

I built a full-screen news reader that lives in the terminal

Installation

Linux / macOS

Windows

Built With

Links

I built a zero-config, 100% serverless portfolio generator so you never have to update yours again.

nishal21 / Publicolio

Publicolio is a zero-config GitHub portfolio generator. It lets you fetch a GitHub profile, select repositories, style the page with theme controls, and generate a shareable link.

Publicolio

Highlights

Runtime Model

How I Built a Memory-Safe Steganography Engine in Rust to Protect Data from AI Scrapers

How I Built a Memory-Safe Steganography Engine in Rust to Protect Data from AI Scrapers

The Concept: LSB Steganography

The Rust Implementation

Breaking Down the Bitwise Math

The Open Standard

I built an open-source, Neo-Brutalist network diagnostic tool (React + Python CLI)

nishal21 / SpedFind

A highly accurate, free, and open-source internet speed test tool featuring a stunning Neo-Brutalist Cyber-HUD and a beautiful Terminal Dashboard.

🚀 SPEDFIND.

✨ Features

🌐 Web Dashboard (React + Tailwind v4)

💻 Command-Line Interface (Python + Rich)

🌐 The Frontend: A Neo-Brutalist Web HUD

💻 The Backend & CLI: Python Power

🚀 Try It Out

I built a Carbon Footprint tracker for my code (using Tauri?!) 🍃

The Problem: Invisible Emissions ☁️

Meet CarbonLint 🌍

Under the Hood 🛠️

The Challenge

Try it out (It's Open Source)