DEV Community: RK Riad Khan

authority-auth: Stop Rolling Your Own Auth — A Framework-Agnostic Python Library

RK Riad Khan — Sun, 16 Aug 2026 16:11:07 +0000

The problem

Every Python web app eventually needs authentication, and every team ends up either gluing together half a dozen libraries or hand-rolling JWT logic. Both paths are full of security traps: weak token validation, no refresh-token rotation, missing lockouts, forgotten MFA.

The library

authority-auth (https://github.com/rkriad585/authority) is a comprehensive, framework-agnostic Python authentication library. One core, written to be used from any stack:

**JWT **access tokens with configurable expiry
Refresh-token rotation with family tracking and reuse detection
TOTP MFA with encrypted secrets and one-time recovery codes
WebAuthn passkeys for passwordless login
RBAC (roles/permissions) with a require_permission guard
API keys, session management, and append-only audit logging
Password security: bcrypt hashing, complexity rules, history enforcement, and HIBP breach checking

Framework integrations

It ships ready-made integrations for FastAPI, Flask, Django, and Starlette, plus framework-agnostic ASGI and WSGI middleware for anything else. Storage is pluggable, with SQLite (sync and async) included.

Example apps you can actually run

Since 0.2.5, every example app is a real web app — server-rendered HTML pages (login, register, dashboard) plus a JSON API, with an HttpOnly-cookie login flow. Run python -m examples.apps.fastapi_app.app (or the Flask/Django/Starlette variants) and poke around.

Get started

pip install authority-auth

Docs: rkriad585.github.io/authority (https://rkriad585.github.io/authority/) · MIT licensed · Python 3.10+

Just shipped TSkeleton 0.2.0 🦴

RK Riad Khan — Sun, 16 Aug 2026 06:05:52 +0000

A zero-dependency library of 24 loading-skeleton Web Components — one tag per popular app: skeleton-facebook, skeleton-github, skeleton-tiktok, skeleton-youtube, skeleton-google and 19 more.

Why I built it:
• No Tailwind, no framework, no runtime deps — each skeleton is a self-contained custom element with its own shadow DOM
• Built-in pulse and shimmer animations
• Three levels of theming: global configure(), per-instance attributes, and deep CSS variables + ::part() hooks
• Tree-shakable subpath imports, ES/CJS/UMD bundles, SSR-safe

Try it from npm or a CDN. Docs and a live playground:
https://rkriad585.github.io/TSkeleton/
https://github.com/rkriad585/TSkeleton

webcomponents #typescript #frontend #opensource

Announcing Abscom — Python-flavored C11

RK Riad Khan — Sun, 16 Aug 2026 02:31:00 +0000

I've spent a while building Abscom, a C11 library of reusable data structures with a Python-inspired dynamic runtime. It's now in review for the two big package registries: vcpkg and ConanCenter.

What you get

Core data structures: dynamic arrays, strings, hashmaps, sets, matrices, data frames, CSV
A dynamic runtime that makes C feel like Python: var, None, List(), Dict(), print, foreach, try/catch
Practical extras: regex, WebSockets, crypto, a small ML stack, image/plotting helpers
Strict C11, no C++ required, zero deps

Example

#include "abscom/abs.h"

int main(void) {
    var list = List();
    list_add(list, 40); list_add(list, 2);
    print("sum = %d", list_sum(list));   // sum = 42
    return 0;
}

Packaging status:

vcpkg — port submitted: all 15 CI jobs (MSVC x86/x64/arm64, Linux, macOS, Android) are green
*ConanCenter *— recipe submitted and building Try it: github.com/rkriad585/Abscom

Cowser: A Fun ASCII-Art Animal CLI in Pure Python

RK Riad Khan — Fri, 14 Aug 2026 12:50:44 +0000

If you miss the good old days of cowsay, you'll love Cowser - a modern,
cross-platform reimagining written in Python with zero runtime dependencies.

What does it do?
Cowser wraps your message in a speech (or thought!) bubble and prints it
above a randomly chosen animal. Greet a friend, pipe in some text, or just
ask for a fortune.

Features

35 built-in animals across 12 categories: cows, cats, pets, birds, sea life, farm, wild, robot, hedgehog, alien, spooky, and mythical creatures
cowsay-style moods: --mode dead, borg, greedy, paranoid, stoned, wired...
Thought bubbles with --think
Custom eyes and tongues via --eyes and --tongue
Word wrapping (-W), disabled with -n
Rainbow, bold, and 17 ANSI colors
--fortune for a random fortune
Render two animals side by side with --and
An interactive REPL session with --interactive
--seed for reproducible output
Art packs: drop .cow, .txt, or .art files in a folder and they load automatically (classic cowsay cowfiles supported)
Config file at ~/.config/neostore/cowser/config.toml

Quick start
pip install cowser

cowser Alice                     # greet with a random animal
cowser --cow owl Bob             # pick a specific animal
echo "From stdin" | cowser       # pipe a message
cowser --fortune                 # random fortune
cowser --rainbow --bold --message "Party time!"

Also a library
cowser is a pure, type-hinted function you can embed in your own tools:

from cowser import render, render_pair, COWS, search_cows

print(render("Hello from my app", cow="owl", eyes="0.0"))

Why I built it
It started as a tiny script and grew into a layered, well-tested package:
a pure rendering core with a thin CLI on top, a stable backwards-compatible
API surface, and no hard dependencies on modern Python. It works on Linux,
macOS, and Windows (including a legacy-console fallback for old cmd.exe).

Try it today:

PyPI: https://pypi.org/project/cowser/
Docs: https://rkriad585.github.io/Cowser/
Repo: https://github.com/rkriad585/Cowser

python #cli #cowsay #asciiart #opensource #rkriad585

How I Built ActiveVPN: A Terminal Tool That Proves (or Exposes) Your VPN

RK Riad Khan — Fri, 14 Aug 2026 12:36:07 +0000

The problem
Your VPN client shows a green "Connected" toggle. That's a marketing claim, not a proof. A tunnel can be up while DNS leaks, IPv6 bypasses the route, or your "anonymous" egress sits in a datacenter that any service can fingerprint.

How ActiveVPN works
The scan collects five groups of signals:

Network interfaces — checks psutil.net_if_addrs() against patterns like tun, tap, utun, wg, ipsec, tailscale, zerotier.
Processes — iterates running processes and matches them against known VPN/Tor binaries using exact/CLI-token matching (this removed a lot of naive-substring false positives, e.g. "vpn" matching random apps).
External IP — queries ip-api.com, ipinfo.io, and ipapi.co in a failover chain for IP, ISP, country, hosting, and proxy flags.
DNS — calls edns.ip-api.com to find the resolver IP your DNS queries actually go through.
IPv4/IPv6 — fetches both via ipify to spot IPv6 leaks around an IPv4-only tunnel.

Verdict scoring
Each signal has a weight (interface 50, VPN process 40, Tor 35, hosting 25, proxy 30). The sum, capped at 100, maps to:

0-19 CLEAN
20-39 SUSPICIOUS
40-74 LIKELY VPN/PROXY
75-100 VPN DETECTED

Extras worth mentioning

Kill switch: sudo activevpn --kill / --kill-force.
Watch mode: activevpn --watch 30 with on_change callbacks for VPN-drop alerts.
History & export: JSON/CSV/TXT from the platform data directory.
Exit codes (0/1/2) so you can wire it into CI.
Library API: import activevpn; result = activevpn.scan(); result.verdict.label.
Docker image + GitHub Pages docs + full pytest suite running on 3 OSes across Python 3.8 and 3.12.

Install
pip install activevpn
activevpn

GitHub: https://github.com/rkriad585/ActiveVPN
Docs: https://rkriad585.github.io/ActiveVPN

Share Files Over LAN with a QR Code - a tiny Python CLI

RK Riad Khan — Fri, 14 Aug 2026 12:14:52 +0000

If you've ever needed to move a file from your computer to your phone
(or to a colleague on the same Wi-Fi), you know the usual options are
all slightly annoying: email, cloud drives, USB cables, chat apps that
compress or require accounts.

qrtransfer solves it with one command and one scan: it serves files
over HTTP on your LAN and prints a QR code in the terminal. Scan it
with your phone's camera and the download starts.

Usage

# Share a file
qrtransfer myphoto.jpg

# Share a whole folder (auto-zipped)
qrtransfer builds/

# Share a text snippet
qrtransfer --text "hello world"

# Receive files from your phone
qrtransfer receive

Nice defaults, honest limits

Stops after the first successful download by default; --keep-alive or --max-downloads N changes that.
Unguessable tokens (secrets.token_urlsafe) so links aren't guessable.
Password via ?passed=SECRET or X-Password header; expiry returns HTTP 410.
--tls for self-signed HTTPS, --ipv6 supported, --clipboard copies the URL.

How it's built

Python 3.9+, stdlib http.server + ThreadingHTTPServer.
psutil for interface/IP detection, platformdirs for config paths, qrcode-terminal for the QR output.
Streaming multipart parser for receive mode - large uploads never buffer fully in memory, and filenames are sanitized against path traversal.
One mutable Session dataclass drives everything; no module globals.

Testing & CI

The repo ships a pytest suite (unit + in-process integration + CLI
end-to-end) run across Ubuntu, Windows, and macOS on Python 3.9/3.11/
3.13, plus ruff linting and pyright type-checking. It's also packaged
as a Docker image (ghcr.io/rkriad585/qrtransfer) and published on
PyPI as qrtransfer-lite.

Install

pip install qrtransfer-lite
# extras: [clipboard], [tls]

Or from source:

git clone https://github.com/rkriad585/qrtransfer
cd qrtransfer && pip install -e ".[dev]"

It's MIT licensed. Feedback and PRs welcome.

Links:

Repo: https://github.com/rkriad585/qrtransfer
Docs: https://rkriad585.github.io/qrtransfer/

I Built a Zero-Dependency English Translator (Python, Stdlib Only)

RK Riad Khan — Fri, 14 Aug 2026 11:53:08 +0000

Why
Most "translator" projects lean on external APIs or heavyweight
dependencies. I wanted to see how far I could get with nothing but the
Python standard library — and have something genuinely usable at the
end. The result: emtranslator, a dictionary-based English-to-Monsu
translator with a CLI and an embeddable API.
The Monsu language
Monsu is fictional, invented for this project. Its vocabulary lives in
a 90-entry dictionary mapping English words to monsu_1 through
monsu_90.
Design highlights

Tokenizing is one regex: (\w+)|([^\w\s])|(\s+). Words get looked up; punctuation and whitespace pass through untouched.
Casing is preserved on the translated output — "Hello" → "Monsu_1".
Unknown words are kept as-is and reported via missing_words().
Reverse mode inverts the dictionary, so Monsu → English works out of the box.
The user dictionary is a flat TOML file at ~/.config/neostore/emtranslator/config.toml, read and written by a hand-rolled parser (because zero deps means zero deps). CLI quick start

emtrans "Hello, world!"          # Monsu_1, monsu_2!
emtrans --reverse "monsu_1"      # hello
emtrans add hi monsu_91          # persist a new word
emtrans --json "hello zebra"     # shows missing words

Library quick start

from emtranslator import Translator
t = Translator()
t.translate("Hello world")       # Monsu_1 monsu_2
t.add_word("hola", "monsu_91")

Testing & tooling

32 pytest tests covering the API and the CLI end-to-end.
Full docs (mkdocs), a Docker image, and a logo. Building it dependency-free was a fun constraint — it makes you reach for the standard library instead of pulling in a package for every small problem. Worth trying on your next side project. → https://github.com/rkriad585/EMTranslator

H9A: Count How Many Times a Digit Appears in Any Range

RK Riad Khan — Fri, 14 Aug 2026 09:24:22 +0000

A classic trick question: how many times does the digit 9 appear between 1 and 100? Most people answer 19. The correct answer is 20 — 9, 19, 29, ..., 99 give 10 in the ones place, and 90–99 give 10 in the tens place. The number 99 is counted twice.

I turned this into a small Python package, H9A.

Install and use

pip install h9a

h9a                       # 9 in 1..100 -> 20
h9a --digit 0 --start 0 --end 9
h9a --json                # machine-readable output
h9a --screenshot          # terminal-style PNG

Why it's fast

The first version iterated the range. A range of a billion numbers meant a billion iterations. I replaced it with a closed-form, per-place formula: for each decimal position, the count comes from division and modulo on the endpoints. Ranges up to 1,000,000,000,000 now resolve in microseconds.

Extras

rich colorized output, pyfiglet ASCII banner, Pillow screenshots
Library API: count_digit() returns a per-place DigitCount
74 tests, ruff, mypy, pre-commit, CI docs + container publishing
MIT-licensed, Python 3.8+

Source: https://github.com/rkriad585/h9a
Docs: https://rkriad585.github.io/h9a/
PyPI: https://pypi.org/project/h9a/

LineSolv: A Natural-Language Calculator for Every Platform

RK Riad Khan — Sat, 11 Jul 2026 15:03:32 +0000

LineSolv: A Natural-Language Calculator for Every Platform

TL;DR — Numi is beautiful but macOS-only. LineSolv brings the same idea to Linux, Windows, and macOS — built with Go + Wails for a ~25 MB binary that starts in under a second. Open source, MIT licensed, no accounts, no telemetry.

The Problem

I've been a Numi user for years. The notepad-style calculator where you just type what you mean — 20% of 150, 5 kg in pounds, sin(pi/4) — and get instant results is genuinely one of those tools that changes how you work with numbers.

But Numi is macOS-only.

If you're on Linux or Windows, you're stuck with either the built-in calculator (which requires clicking buttons) or a full-blown spreadsheet app just to do quick math. There's a real gap in the market for a beautiful, keyboard-driven calculator that works everywhere.

So I built one.

Why Go + Wails, Not Electron?

I considered Electron first — it's the obvious choice for "build a desktop app with web technologies." But the numbers didn't add up:

	Electron	Go + Wails
Binary size	100–200 MB	20–50 MB
Memory (idle)	80–150 MB	20–40 MB
Startup time	2–5 seconds	< 1 second
Native feel	Heavy	Lightweight

Wails v2 lets you write the backend in Go and the frontend in whatever JS/TS framework you want (I used vanilla TypeScript + Tailwind). The Go backend compiles to a single native binary. The frontend runs in the system's native WebView — no bundled Chromium.

The result: a ~25 MB app that starts instantly and uses almost no memory.

What It Does

LineSolv is a notepad-style calculator. You type natural language or math expressions on the left, and results appear instantly on the right.

Natural Language That Actually Works

You don't need to learn syntax. Just type what you'd say out loud:

twenty five percent of 200          → 50
5 kg in pounds                      → 11.0231 lb
what is pi plus five                → 8.14159
2h30m in minutes                    → 150 min

The parser handles natural language (twenty five, half as much as 100), unit conversions across 100+ units in 14 categories, percentage math, and even purchase calculations (3 items at $10 each with a 15% discount).

Variables and Context

Lines reference each other automatically. Type x = 42 on one line, and x * 2 on the next line gives you 84. Use of that or then to chain results:

100
+ 10%            → 110 (10% of previous result)
of that           → 121 (10% again)

Step-by-Step Evaluation

Hit Ctrl+S to open the Steps panel and see exactly how your expression was parsed and computed — every operation, every intermediate value. Great for learning or debugging complex calculations.

Function Graphing

Type plot x^2 or graph sin(x) and a live chart renders in the Graph panel. Supports custom ranges (plot x^2 from -10 to 10), multiple series, and Chart.js-powered interactive tooltips.

Multiple Notes, Persistent Storage

Create as many calculation notebooks as you need. Everything persists to a local SQLite database. Drag to reorder, search across all notes, export to PDF, JSON, Markdown, or plain text.

7 Themes

Dark, Light, Neon, Red, Obsidian, Plasma, and Blood — switch instantly in Settings. Every theme is carefully crafted for readability and contrast.

Everything Else

26 built-in math functions — sin, cos, sqrt, log, round, abs, factorial, and more
Live currency conversion — USD, EUR, GBP, JPY, and more via exchange-rate API (with offline cache)
Customizable shortcuts — rebind any keyboard shortcut
Print with formatting — A4 layout with note header, watermark, and page numbers
Undo/Redo — 200-entry history stack
PDF export — formatted documents with dates and page numbers

The Technical Journey

The Parser

The core is a recursive-descent parser in Go (~2,100 lines) with a 15-step natural language preprocessing pipeline. It handles operator precedence (PEMDAS), implicit multiplication (2pi), chained operations, and over 100 unit definitions.

The naturalize() function converts English words and phrases into tokenized math expressions before the parser sees them. It handles:

Word numbers (twenty five → 25)
Percentage phrases (10% of 200)
Unit conversions (5 kg in pounds)
Purchase math (3 items at $10 each with 15% discount)

The Frontend

Vanilla TypeScript, no framework. Just classes, DOM APIs, and Tailwind CSS. The app has 11 components, 2 stores, and a 200-entry undo/redo stack — all in ~3,000 lines.

Key architectural decisions:

No virtual DOM — direct DOM manipulation with diffing for the line-number gutter
Debounced evaluation — 150ms debounce with stale-result detection
Lazy panel rendering — panels build their DOM only when first opened

The Build

Wails v2 handles the cross-compilation. One wails build command produces:

Linux: standalone binary + .deb package
macOS: .dmg (Intel + Apple Silicon)
Windows: NSIS installer

CI runs on GitHub Actions with automatic releases on tag push.

Get Involved

# Clone and run
git clone https://github.com/rkriad585/LineSolv.git
cd LineSolv
wails dev

# Or just download a release
# https://github.com/rkriad585/LineSolv/releases

LineSolv — is a lot works, but there's a lot more to build. If you've ever wished Numi worked on Linux, or you just want a fast, private calculator that respects your time, give it a try.

Contributions welcome. Open an issue, send a PR, or just star the repo if you want to follow along.

GitHub: github.com/rkriad585/LineSolv
License: MIT
Built with: Go, Wails v2, TypeScript, Tailwind CSS, Vite