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

Hi, I'm Soumalya — a developer with a genuine interest in Python and Rust, 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 two main projects sit in fairly different spaces. 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. Both came 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 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)
• Omarchy + ML4W

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 →

 

 

┌─────────────────────────────────────────────────────────────────────────────┐
│                      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.      │
│                                                                             │
│  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
• 🎬 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
• 🤖 LLM integration in tooling — making AI-assisted code generation genuinely useful rather than surface-level

💬 Happy to collaborate on Rust–Python tooling, TUI projects, 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", "Omarchy Linux"]
    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.",
    }

    currently = "Figuring out how far you can push Python with a bit of Rust. 🦀"

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