---

"Write code that machines execute flawlessly and humans can read just as easily."

🌿 @programmersd21

✨ GitHub profile: https://github.com/programmersd21

Hi, I'm Soumalya — a developer with a genuine interest in Python, Rust, and Go, a strong preference for terminal-first workflows, and a focus on building open-source tools that are both useful and well-crafted. I care about the details: clean APIs, clear documentation, and code that holds up as a project grows.

My projects span a few different spaces. Bangen is an ASCII banner renderer with a composable 30+ effect pipeline, live split-screen TUI, and animated GIF export — built in Python with rich, pyfiglet, and Pillow. EfficientManim is a node-based visual editor for Manim — it brings a more interactive, IDE-like workflow to mathematical animation without giving up the Python coding layer underneath. pyratatui is a Python binding for Ratatui, bringing Rust's high-performance TUI engine to Python developers through a fully Pythonic API. Kairo is a keyboard-first terminal task manager built in Go — offline-first, SQLite-backed, with a Lua plugin system and optional Git sync. All four come from the same motivation: closing the gap between what a tool can do and how comfortably a developer can actually use it.

When I'm away from the keyboard, you'll usually find me following cricket — particularly anything involving Mitchell Starc 🏏.

How I like to approach development:

• 🔩 Performance where it matters — reaching for Rust or Go when Python's speed becomes a genuine bottleneck
• 🧩 Small, composable libraries — focused tools that do one thing well and integrate cleanly with others
• 📺 Terminal-first thinking — TUIs as first-class interfaces, not afterthoughts
• 🌐 Open-source done properly — real documentation, semantic versioning, and maintained codebases
• 🔬 Clarity over cleverness — code that the next contributor can understand and build on

• ✨ Windows 11
• 💪 Android (DerpFest GSI)
• 🚀 CachyOS + ML4W

Fast TUI banner editor with a composable 30+ effect library, JSON presets, and transparent PNG/GIF export.

Bangen is an ASCII banner renderer built on pyfiglet, rich, and Pillow. It ships with a live split-screen TUI for interactive editing, a Typer-powered CLI for scripted workflows, and an export pipeline that handles static PNG, animated GIF (with transparency), and plain TXT — all from the same tool.

Effects are composable and order-sensitive, grouped into five categories: motion (wave, bounce, drift, scroll), visual (glow, pulse, rainbow_cycle, scanline), temporal (typewriter, fade_in, wipe, stagger), distortion (glitch, chromatic_aberration, melt, fragment), and signature (matrix_rain, fire, electric, neon_sign, particle_disintegration). Stack them freely — glitch + chromatic_aberration + pulse for cyberpunk, glow + neon_sign for neon, matrix_rain + typewriter for the obvious.

# Styled render with effect stack
bangen "SYSTEM READY" --font slant --gradient "#7c3aed:#06b6d4" --effect glow --effect wave

# Export animated GIF
bangen "HELLO" --effect wave --effect glow --export-gif banner.gif --gif-duration 3 --gif-fps 20

# AI-prompted style
bangen "HELLO" --ai "retro CRT hacker title"

# Full-terminal screensaver
bangen "SIGNAL" --screensaver --screensaver-seed 42

Key Features:

Bangen turns a single CLI call into a full creative effect pipeline — from interactive TUI editing to production-ready animated exports.

🔗 View on GitHub →

A visual IDE that makes building Manim animations feel more like composing a scene and less like debugging a render loop.

EfficientManim is a node-based visual editor for creating mathematical animations with Manim. Instead of editing scripts and re-running the renderer to check results, you build animations by connecting nodes in a visual graph — linking scenes, objects, and transformations while watching things update in real time. The full Python animation model stays intact underneath; the editor just gives you a more immediate way to work with it.

Built with Qt (PySide6), the interface is designed to feel like a proper desktop IDE while keeping the setup lightweight and developer-friendly.

Key Features:

EfficientManim makes Manim more approachable for visual thinkers, without taking away the coding control that makes it powerful.

🔗 View on GitHub →

Rust-quality terminal UIs, authored entirely in Python.

pyratatui is a Python binding for Ratatui — a well-regarded Rust library for building terminal user interfaces. It gives Python developers access to Ratatui's rendering engine through a fully Pythonic API, so you get the performance and widget quality of the Rust TUI ecosystem without needing to write any Rust yourself.

The binding is built with PyO3 and distributed as binary wheels via Maturin, making installation straightforward and keeping the Python–Rust boundary overhead minimal. If your project already uses asyncio, pyratatui supports async terminal handling so it slots naturally into event-driven architectures.

Key Features:

pyratatui bridges Rust's terminal rendering performance with Python ergonomics — so you can build serious terminal applications with minimal Rust exposure.

🔗 View on GitHub →  |  View on PyPI →

⌛ Time, executed well.

Kairo is a keyboard-first, offline-first terminal task manager designed for focused execution. Built with Bubble Tea and Lip Gloss, it uses an Elm-inspired state-machine architecture to manage views, modes, and task lifecycle — all stored locally in a SQLite database with WAL and auto-migrations.

What makes Kairo distinct is how seriously it treats extensibility and data sovereignty: tasks can optionally sync via a Git-backed JSON store (no external services needed), and the Lua plugin system lets you add custom commands and views with hot-reload, no recompile required.

Key Features:

Architecture highlights: Kairo uses a clean modular layout — ui/, storage/, sync/, search/, plugins/, and core/ are fully decoupled. The search engine maintains an in-memory index with contiguity-weighted fuzzy scoring. The plugin host embeds Gopher-Lua and exposes a kairo global API for task CRUD and UI notifications.

Kairo keeps task management entirely in your terminal, entirely under your control — from the storage layer to the plugin runtime.

🔗 View on GitHub →

 

 

┌─────────────────────────────────────────────────────────────────────────────┐
│                      A FEW THINGS I TRY TO KEEP IN MIND                     │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  01. Make it correct.   02. Make it clear.   03. Make it fast.             │
│      In that order. Every time.                                             │
│                                                                             │
│  04. If Python isn't fast enough, write Rust and call it from Python.      │
│      If you need something tight and portable, write Go.                   │
│                                                                             │
│  05. A TUI is not a downgrade — it's a considered choice.                  │
│                                                                             │
│  06. A public API is a promise. Don't make promises you won't keep.        │
│                                                                             │
│  07. Open-source deserves the same care as production software.             │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

• 🦀 Deeper Rust — async patterns, lifetimes, and tighter PyO3 boundary design
• 🐹 Idiomatic Go — concurrency patterns, embedding, and pushing Bubble Tea's state-machine model further
• 🎬 Animation tooling — node graph architectures, scene serialisation, and editor UX patterns
• 🖥️ Terminal protocols — Kitty graphics protocol, sixel support, and true-colour consistency across emulators
• 🧪 Property-based testing — Hypothesis for Python, proptest for Rust
• 🔌 Plugin system design — sandboxed Lua runtimes, lifecycle hooks, and safe API surfaces
• 🤖 LLM integration in tooling — making AI-assisted code generation genuinely useful rather than surface-level

💬 Happy to collaborate on Rust–Python tooling, Go TUI apps, plugin system design, visual editors, or anything performance-related. The best way to reach me is through an issue or discussion on one of the repositories above — I try to stay on top of them.

class Soumalya:
    location     = "India 🇮🇳"
    os_of_choice = ["DerpFest AOSP", "CachyOS"]
    editor       = "Neovim (yes, really)"
    shell        = "zsh + dotfiles that took too long to configure"
    terminal     = "kitty / ghostty"

    interests = {
        "cricket"   : "Mitchell Starc — best left-arm pacer of his generation, no debate 🏏",
        "coding"    : "Late-night sessions with lo-fi and a clean 80-column terminal",
        "philosophy": "Code is read far more than it's written. Optimise for the reader.",
    }

    languages   = ["Python 🐍", "Rust 🦀", "Go 🐹"]
    currently   = "Building keyboard-first tools in Python, Rust, and Go. 🖥️"

Built with 🐍 Python, 🦀 Rust, 🐹 Go, and a genuine fondness for the terminal.