DEV Community: Nishal K

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-config GitHub portfolio generator It lets you fetch a GitHub profile, select repositories, style the page with theme controls, and generate a shareable link.

What It Does

Fetches profile and repo data from GitHub.
Supports optional personal token input in builder mode for private/owner repos.
Provides 6 visual themes.
Provides editor controls for layout and styling.
Generates shareable portfolio URLs with selected repositories and style options encoded in query params.
Optionally shortens links through a Cloudflare Worker.
Supports short link domain choice between workers.dev and custom domain.
Caches builder state so returning users can continue editing after refresh.
Supports Update Link flow to keep the same short URL when the backend supports slug updates.

How It Works

Publicolio has two runtime modes.

Builder mode

If no user and theme query params are present, the app renders the interactive builder UI.
User enters GitHub username, picks repos…

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?