DEV Community: Riya Dhami

💀Ghost in the Machine: Where 90s Retro Horror Meets the Digital Ofrenda🕯️

Riya Dhami — Wed, 28 Oct 2026 12:59:26 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine

What I Built

PhantasmLocal is a dual-mode, 100% privacy-respecting web application that bridges the eerie nostalgia of 1990s retro horror & BBS dial-up terminals (October 31 / Halloween) with the warm, reverent memory-keeping of Día de los Muertos (November 1–2).

When the calendar thinners between past and present, memories shouldn't depend on uptime servers or cloud subscriptions. PhantasmLocal is built around an offline-first philosophy, offering:

🕯️ Digital Memory Ofrenda (Altar): A candle-lit space where users can pin family photos and memories to a Polaroid altar and instantly generate respectful rhyming Calaveras Literaria poems using local open-weight AI logic.
💻 199X Haunted TTY & BBS Séance: A retro CRT terminal featuring green-and-red phosphor aesthetics, anomaly detection via TabPFN process scanning, an extinct language séance room (COBOL, Turbo Pascal, Flash), and a Shortwave Ghost Radio tuner.
🎵 Autonomous Horror Web Audio Engine: A pure Web Audio API synthesizer that runs entirely in the browser without external files, playing subterranean ambient drones, static bursts, and ghostly laughs.

Demo

🔗 Live Demo: https://riyadhami13.github.io/phantasmlocal/

Code

RiyaDhami13 / phantasmlocal

PhantasmLocal is a dual-mode, 100% privacy-respecting local web application built for the Hacktoberfest "Ghost in the Machine" challenge.

🕯️💀 PhantasmLocal: Offline Memory Ofrenda & 199X Haunted BBS

“What is a ghost, if not an unextinguished process running on hardware we forgot we owned?”

PhantasmLocal is a dual-mode, 100% privacy-respecting local web application built for the Hacktoberfest "Ghost in the Machine" challenge. It combines the reverent warmth of Día de los Muertos (Nov 1–2) with the eerie nostalgia of 1990s retro horror & BBS dial-up terminals (Oct 31).

Built entirely around open-source AI principles, PhantasmLocal operates with zero cloud telemetry or external API dependencies—keeping family stories, memorial photos, and system diagnostics entirely on your local machine.

🌟 Core Features

1. 🕯️ Día de los Muertos Digital Memory Ofrenda (Altar)

Warm Candlelit Aesthetic: Candle-lit gradients, marigold flower accents, and flickering memorial typography.
Polaroid Memory Vault: Pin family photos and stories with instant client-side rendering and grainy vintage filters.
Local AI Calavera Literaria Generator: Synthesizes custom, witty, and heartwarming rhyming…

View on GitHub

How I Built It

PhantasmLocal is engineered with clean, modular vanilla web technologies:

index.html: Semantic structural layout housing the BBS navigation, CRT scanline layers, ofrenda forms, and terminal windows.

style.css: Custom 199x retro styling, CRT flickering keyframes, warm candle glow animations, and chunky Win95-style bevels.

script.js: The core engine, incorporating a real-time Web Audio API synthesizer for procedural soundscapes, a terminal command parser, a FileReader Polaroid processor, and localized poetic synthesis modules inspired by open-weight architectures like Gemma.

TabPFN Integration: The haunted terminal features a scan command powered by a simulated TabPFN tabular anomaly detection engine (TabPFN 3.5 Engine). It runs local kernel telemetry checks to identify phantom background processes on port 666-showcasing how fast, prior-data-fitted tabular models excel at quick, zero-training classification and tabular diagnostics.

Why Does Open Innovation Matter?

When building tools for remembrance, cultural heritage, and personal history, privacy isn't a feature-it's a sacred requirement.

Relying on closed cloud APIs for family remembrance means your personal history is tied to corporate cloud lifecycles. If a service shuts down or deprecates its API, your digital altar vanishes. Open-source models and vanilla browser runtimes guarantee data sovereignty: family photographs and deeply personal memories never leave the user's device or feed third-party training data. Open innovation makes permanent, self-sovereign digital preservation possible.

The Spirit of It

PhantasmLocal treats technology not just as a tool for productivity, but as a medium for storytelling. Watching the candle-lit Polaroid altar glow against the harsh green CRT phosphor lines brings two contrasting worlds together-reminding us that beneath every layer of code and hardware, human memories are what truly endure.

Prize Categories

Best Use of Gemma
Best Use of TabPFN

Thank you for reading!

📝 Copilot DevLog CLI: Track Developer Decisions & Generate Clean Markdown Logs

Riya Dhami — Thu, 22 Oct 2026 11:12:12 +0000

This is a submission for the MLH x DEV Writing Challenge

What I Built

During fast-paced hackathons and daily coding sessions, it is easy to lose track of smaller bugfixes, architectural choices, and technical breakthroughs.

To solve this, I built copilot-devlog-cli—a lightweight, local-first Python command-line tool designed to record dev notes in real-time and export them into structured Markdown post-mortems (DEVLOG_SUMMARY.md).

Inspired by a challenge to use AI coding assistants to construct practical applications, I wanted to build something I could actually use while building future projects. It allows developers to quickly log entries directly from the terminal and export clean summaries without interrupting their flow.

Key Learnings & Features:

Subcommand CLI Interface: Implemented add, view, and export subcommands using Python's argparse.
Robust Storage Handling: Safely stores entries in devlog_entries.json, gracefully reporting unreadable or malformed files rather than failing silently.
Custom Exporting: Supports custom log file targeting (--log-file) and flexible export destinations (--output).

Demo

RiyaDhami13 / copilot-devlog-cli

A lightweight terminal activity logger and Markdown exporter built in Python with GitHub Copilot.

copilot-devlog-cli

A lightweight Python CLI to record daily development logs and export them to Markdown.

Requirements

Python 3.8+

Usage

From the repository root, run:

python devlog.py <command> [options]

Use --log-file before the subcommand to store entries in a different JSON file. Missing log files start empty; malformed or unreadable files are reported as CLI errors instead of being silently replaced.

Add a log entry

python devlog.py add --title "Fix auth bug" --category "Bugfix" --notes "Resolved token refresh issue"

View all entries

python devlog.py view

Export Markdown summary

python devlog.py export

To write the Markdown summary somewhere else, use --output:

python devlog.py export --output reports/devlog.md

Output files

devlog_entries.json: local JSON storage for all entries
DEVLOG_SUMMARY.md: generated Markdown summary document

View on GitHub

Here is copilot-devlog-cli in action inside the terminal:

1. Add a log entry

python devlog.py add --title "Fix auth token refresh" --category "Bugfix" --notes "Resolved silent 401 response on expired JWT"

2. Viewing Recent Dev Notes

python devlog.py view

3. Exporting Markdown Summary

python devlog.py export --output reports/devlog.md

🛠️ Development Log Summary

[Bugfix] Fix auth token refresh

Notes: Resolved silent 401 response on expired JWT
Timestamp: 2026-10-22 14:30

Partner Technologies

GitHub Copilot
I leveraged GitHub Copilot as my primary pair programmer throughout the development process.

How it was implemented:

CLI Scaffolding: Copilot helped generate the boilerplate for complex argparse subcommand structures and optional flag parser rules (--log-file, --output).
Error & Edge-Case Handling: Guided the implementation of safe JSON parsing logic—ensuring missing files start gracefully as empty datasets while corrupted files trigger informative CLI error messages.
Markdown Formatter: Assisted in writing string serialization routines to convert raw JSON logs into clean, readable Markdown documents.

Working with Copilot significantly accelerated the build phase, allowing me to focus on UX and error handling rather than syntax lookup.

Hackathon Experience

Building this tool during the MLH challenge window was an incredible learning curve!

The experience highlighted how AI assistants can transform simple prompt challenges into functional developer utilities. Interacting with the global hacker community and seeing the creative ways developers solve everyday friction points inspired me to focus on local-first, developer-centric tooling. What I'll remember most is the satisfaction of using the tool I built to log the process of building it!

Thanks for reading!

🦥 TidySloth CLI: The Local-First File Organizer That Embraces Sloth Mode

Riya Dhami — Thu, 22 Oct 2026 06:07:08 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

What I Built

TidySloth CLI is a lightweight, privacy-focused, local-first Python command-line utility designed to automate digital file organization.

Instead of spending precious time sorting messy Downloads, Desktop, or project folders, TidySloth scans your target directory, categorizes clutter into clean subfolders (Code, Documents, Images, Archives, and Others), and generates a clear Markdown summary index (TIDY_INDEX.md). It channels your inner sloth by handling the tedious file cleanup you keep putting off—all in milliseconds on your own machine.

Demo

Here is tidysloth-cli in action inside VS Code:

Key Features:
scan mode: Previews file distribution and updates the index without moving anything.

tidy mode: Safely organizes files into categorized subfolders.

--dry-run flag: Lets you preview exact move operations risk-free.

TIDY_INDEX.md Generation: Keeps a clean Markdown manifest of all organized files.

Code

RiyaDhami13 / tidysloth-cli

A local-first Python file-organizer CLI that cleans up digital clutter at sloth speed.

🦥 tidysloth-cli

A local-first Python file-organizer CLI that cleans up digital clutter at sloth speed. Built with GitHub Copilot.

Features

Organizes files into category folders: Code, Documents, Images, Archives, and Others
Uses pathlib for safe path handling and argparse for CLI parsing
Supports a non-destructive preview mode with --dry-run
Generates a clean markdown summary index (TIDY_INDEX.md) for both scan and tidy runs

Requirements

Python 3.8+

Usage

Run from this repository root:

python tidysloth.py --help

Scan a directory

Scans files and writes TIDY_INDEX.md with category counts and file listings.

python tidysloth.py scan --path ./target_folder

If no target is provided, the current directory is used:

python tidysloth.py scan

Tidy a directory

Moves files into category subfolders and updates TIDY_INDEX.md.

python tidysloth.py tidy --path ./target_folder

Dry run

Preview all move operations without changing any files:

python tidysloth.py tidy --path ./target_folder --dry-run

File categorization

Code…

View on GitHub

How I Built It

TidySloth was engineered from the ground up using GitHub Copilot as an AI pair programmer.

Built using Python standard libraries (pathlib for safe cross-platform file system operations and argparse for subcommands), GitHub Copilot assisted across the entire build workflow:

CLI Architecture: Copilot scaffolded clean subcommand parsing (scan and tidy).
Safe File Operations: Assisted in implementing dry-run previews, collision prevention, and directory creation logic.
Markdown Generation: Automated the string formatting logic for generating the TIDY_INDEX.md report.

Why Does Open Innovation Matter?

Digital file clutter often contains sensitive information—personal documents, private code snippets, financial records, or configuration files.

100% Private & Offline: TidySloth processes everything locally. Your private filenames and directory contents are never transmitted to cloud servers or third-party APIs.

Zero Cost & Latency: Runs instantly with zero cloud dependencies, API keys, or subscriptions.

Reliable Local Execution: It works anywhere—on a flight, off the grid, or on low-power devices.

My Agent Session

The Lazy Payoff

Sorting a cluttered downloads directory manually usually takes 10–15 minutes of tedious drag-and-drop effort. TidySloth completes the same job in less than 1 second. I used it this week to clean up my messy project workspace and instantly generate structured Markdown indexes without breaking my focus.

Prize Categories

Best Use of GitHub Copilot (Built using GitHub Copilot for code architecture, CLI parsing, and Markdown generation).

Thanks for reading
!

Why I Built VaultDocs AI: Local-First Contract Risk Screening with Open Models

Riya Dhami — Thu, 15 Oct 2026 16:18:15 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

VaultDocs AI is a local-first, privacy-guaranteed contract risk screening assistant tailored for freelancers, contractors, and boutique agency owners.

Freelancers frequently sign Master Services Agreements (MSAs), Statements of Work (SOWs), and Non-Disclosure Agreements (NDAs) loaded with unfavorable clauses-such as unlimited indemnification, intellectual property handovers, oppressive payment terms (Net 90+), and unilateral termination rights. Hiring a legal professional for every contract review is cost-prohibitive for independent workers. However, uploading confidential client contracts to commercial cloud LLMs (like standard online AI chat tools) directly violates client non-disclosure agreements (NDAs) and risks exposing sensitive commercial data to server logs and third-party AI training pipelines.

VaultDocs AI solves this by running 100% on the user's local machine with zero cloud connectivity. No contract text, vector embeddings, or prompts ever leave local memory.

The application:

Parses PDF contracts into page-boundary chunks.
Uses a fast in-memory hybrid ranker (BM25 + legal keyword boost) and dense FAISS vector index to retrieve risk-prone sections in under 5 milliseconds.
Performs local open-weight LLM screening using llama3.2:1b, gemma:2b, or qwen2.5:3b via Ollama.
Validates model citations directly against extracted PDF text to eliminate hallucinations.
Renders a professional, interactive 3-column legal review workstation with customizable risk scoring (0–100) and downloadable Markdown audit reports.

Demo

YouTube Walkthrough: https://youtu.be/pede-5xhahY

Code

The complete project is open-source and up on GitHub:

https://github.com/RiyaDhami13/vaultdocs-ai

How I Built It

I wanted to build something practical that relies entirely on open-source AI tools running locally:

Local LLM Runtime (Ollama): I hooked up Ollama (127.0.0.1:11434) so it runs lightweight, open-weight models like llama3.2:1b, gemma:2b, and qwen2.5:3b right on my machine without any external APIs. 2.PDF Processing (PyMuPDF): Used PyMuPDF to parse contracts page-by-page while keeping exact page numbers intact so citations map back correctly.
Hybrid Retrieval (FastClauseRetriever): To avoid heavy search lags, I built a fast in-memory BM25 and legal keyword ranker that pulls relevant clauses in under 5ms, backed by SentenceTransformers and FAISS CPU when needed.
Pydantic v2 & JSON Auto-Repair: Small local models sometimes cut off JSON responses or format things slightly differently. I wrote a custom auto-repair handler with Pydantic v2 to safely catch truncated responses, fix them up, and parse them cleanly without throwing errors.
Citation Validation Engine: Cross-checks the model's extracted quotes against the actual contract text to verify page numbers and flag anything unverified.

Why Does Open Innovation Matter?

For a tool dealing with legal contracts and sensitive freelance client work, open innovation wasn't just a nice-to-have-it was the only way this could work.

If I used a closed cloud API, every single clause, financial rate, and proprietary scope would get piped through a third-party server, instantly breaking client non-disclosure agreements. Running open-weight models locally via Ollama means absolute data privacy with zero cloud leakage. Plus, keeping the per-query runtime cost at $0 makes it actually sustainable for freelancers who don't want to deal with unpredictable token billing.

Prize Categories

Best Use of Gemma: Used Google's open-weight model family (gemma:2b) running locally via Ollama for fast, private contract screening.
Best Use of GitHub Copilot: Leveraged GitHub Copilot throughout project scaffolding, UI layout design, and service module refactoring.

Thanks for reading!

🥾TrailQuest AI: Forcing myself to touch grass with local Python, Gemma & Ollama 🌱

Riya Dhami — Sat, 10 Oct 2026 07:20:50 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

I built TrailQuest AI, an offline-first, local AI outdoor adventure generator designed to break screen fatigue by turning local AI inference into physical outdoor quests.

As an engineering student spending long hours in front of my desktop PC, I noticed how easy it is to fall into screen lock when trying to take a break. TrailQuest AI minimizes screen interaction to under 30 seconds:

You pick your available time (10 to 120 minutes) and challenge level.
You select an outdoor vibe (Mindful & Chill, Scavenger Hunt, Energetic Walk, or Nature Photography) and current weather/setting.
In seconds, local inference streams a structured 3-step "Quest Card" with route goals, mindfulness observation tasks, reflection photo challenges, and trail safety tips.

Once the card appears, your screen experience ends—you step outside and touch grass.

Demo

Example Quest Card Output (Sunlit Sojourn: A Mindful Walk):

Step 1 (Route & Goal): Complete a 1-mile loop around the park.

Step 2 (Observation & Mindfulness): Notice how sunlight filters through the leaves, creating dancing patterns on the ground. Count at least 5 different types of leaf shapes or colors as you walk.

Step 3 (Reflection & Photo Challenge): Snap a photo where you feel most relaxed and peaceful. Reflect on why this moment feels so rejuvenating.

Safety & Trail Tip: Stay hydrated and wear sunscreen to protect yourself from the sun's rays.

Code

RiyaDhami13 / trailquest-ai

Demo

🥾 TrailQuest AI — Offline Outdoor Adventure Generator

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

TrailQuest AI is a lightweight, local-first web application that turns screen time into offline real-world outdoor adventures.

Instead of endlessly scrolling through social media or struggling to decide what to do outside, users pick their available time (e.g., 10–120 minutes), their desired outdoor vibe (Mindful & Chill, Scavenger Hunt, Energetic Walk, Nature Photography, Rainy Day Walks, Fall Foliage Tracker, Night Sky Observation, etc.), weather/season setting, and immediate location.

In seconds, TrailQuest AI generates a personalized, 3-step physical "Quest Card" with clear goals, observation challenges, reflection prompts, and safety tips. Once generated, the screen experience ends and the user steps outside to "touch grass."

It is built for students, remote workers, and anyone looking to break screen fatigue without exposing their daily location habits…

View on GitHub

How I Built It

TrailQuest AI is built around a pure Python, production-grade local AI architecture:

Frontend & Dashboard: Built with Streamlit for a clean, dark-mode UI complete with real-time telemetry, model status indicators, and local sidebar controls.
Local AI Engine: Powered by Ollama running open-weight models (gemma:2b / qwen2.5:3b) locally on desktop hardware.
Real-Time Token Streaming: Renders generated quest cards character-by-character as tokens stream directly from the local LLM runtime.
Pydantic Schema Validation: Uses structured JSON output enforcement to guarantee every generated quest contains valid Route, Observation, Reflection, and Safety sections.
Multi-Model Fallback: Implements resilient fallback logic (qwen2.5:3b -> llama3.2:1b / gemma:2b) so quest generation succeeds even if the primary model is busy or uninitialized.
Offline Streak & Quest Logging: Built-in SQLite database (trailquest.db) that tracks local outdoor streaks and quest completion history without cloud telemetry.

Running it locally


bash
# Pull open-weight models via Ollama
ollama pull gemma:2b
ollama pull qwen2.5:3b

# Clone & run locally
git clone [https://github.com/RiyaDhami13/trailquest-ai.git](https://github.com/RiyaDhami13/trailquest-ai.git)
cd trailquest-ai
pip install -r requirements.txt
streamlit run app.py

##Why Does Open Innovation Matter?
Using open-weight models locally made this project fundamentally better than relying on a closed cloud API:

1. 100% Habit & Location Privacy: Personal routines, free time schedules, and local neighborhood traits stay strictly on my desktop PC. Zero prompt logs or location data leave the machine.

2. $0 Operational Cost: By running inference locally via Ollama, the app requires $0 in cloud API keys or monthly subscriptions, making open AI tools freely accessible to student builders.

3. True Offline Trail Capability: Open-weight models execute directly on consumer hardware without an active internet connection—allowing quest generators to run seamlessly on a laptop at remote trailheads with zero cell coverage.

##[](
![ ](https://dev-to-uploads.s3.us-east-2.amazonaws.com/uploads/articles/no6uohidvhdgbnf6v1sc.png))Taking It Outside 🥾
To test the app, I selected a 15-minute "Mindful & Chill" quest card on my PC, put my desktop on sleep mode, and went for a loop around my neighborhood.

The app tasked me with observing sunlight patterns through tree leaves and collecting 5 distinct leaf shapes without looking at my phone. Having the AI generate a structured, lightweight physical task made stepping away from my workstation effortless—the screen time took under 30 seconds, and I spent the next 20 minutes completely offline.
![ ](https://dev-to-uploads.s3.us-east-2.amazonaws.com/uploads/articles/ukhk5xbx9bpzfzgeq1k4.png)

🥾TrailQuest AI: Forcing myself to touch grass with local Python, Gemma & Ollama 🌱

Riya Dhami — Fri, 09 Oct 2026 16:09:34 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

I built TrailQuest AI, an offline-first, local AI outdoor adventure generator designed to break screen fatigue by turning local AI inference into physical outdoor quests.

You pick your available time (10 to 120 minutes) and challenge level.
You select an outdoor vibe (Mindful & Chill, Scavenger Hunt, Energetic Walk, or Nature Photography) and current weather/setting.
In seconds, local inference streams a structured 3-step "Quest Card" with route goals, mindfulness observation tasks, reflection photo challenges, and trail safety tips.

Once the card appears, your screen experience ends—you step outside and touch grass.

Demo

Example Quest Card Output (Sunlit Sojourn: A Mindful Walk):

Step 1 (Route & Goal): Complete a 1-mile loop around the park.

Step 2 (Observation & Mindfulness): Notice how sunlight filters through the leaves, creating dancing patterns on the ground. Count at least 5 different types of leaf shapes or colors as you walk.

Step 3 (Reflection & Photo Challenge): Snap a photo where you feel most relaxed and peaceful. Reflect on why this moment feels so rejuvenating.

Safety & Trail Tip: Stay hydrated and wear sunscreen to protect yourself from the sun's rays.

Code

RiyaDhami13 / trailquest-ai

Demo

🥾 TrailQuest AI — Offline Outdoor Adventure Generator

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

TrailQuest AI is a lightweight, local-first web application that turns screen time into offline real-world outdoor adventures.

It is built for students, remote workers, and anyone looking to break screen fatigue without exposing their daily location habits…

View on GitHub

How I Built It

TrailQuest AI is built around a pure Python, production-grade local AI architecture:

Frontend & Dashboard: Built with Streamlit for a clean, dark-mode UI complete with real-time telemetry, model status indicators, and local sidebar controls.
Local AI Engine: Powered by Ollama running open-weight models (gemma:2b / qwen2.5:3b) locally on desktop hardware.
Real-Time Token Streaming: Renders generated quest cards character-by-character as tokens stream directly from the local LLM runtime.
Pydantic Schema Validation: Uses structured JSON output enforcement to guarantee every generated quest contains valid Route, Observation, Reflection, and Safety sections.
Multi-Model Fallback: Implements resilient fallback logic (qwen2.5:3b -> llama3.2:1b / gemma:2b) so quest generation succeeds even if the primary model is busy or uninitialized.
Offline Streak & Quest Logging: Built-in SQLite database (trailquest.db) that tracks local outdoor streaks and quest completion history without cloud telemetry.

Running it locally


bash
# Pull open-weight models via Ollama
ollama pull gemma:2b
ollama pull qwen2.5:3b

# Clone & run locally
git clone [https://github.com/RiyaDhami13/trailquest-ai.git](https://github.com/RiyaDhami13/trailquest-ai.git)
cd trailquest-ai
pip install -r requirements.txt
streamlit run app.py

##Why Does Open Innovation Matter?
Using open-weight models locally made this project fundamentally better than relying on a closed cloud API:

1. 100% Habit & Location Privacy: Personal routines, free time schedules, and local neighborhood traits stay strictly on my desktop PC. Zero prompt logs or location data leave the machine.

2. $0 Operational Cost: By running inference locally via Ollama, the app requires $0 in cloud API keys or monthly subscriptions, making open AI tools freely accessible to student builders.

3. True Offline Trail Capability: Open-weight models execute directly on consumer hardware without an active internet connection—allowing quest generators to run seamlessly on a laptop at remote trailheads with zero cell coverage.

##[](
![ ](https://dev-to-uploads.s3.us-east-2.amazonaws.com/uploads/articles/no6uohidvhdgbnf6v1sc.png))Taking It Outside 🥾
To test the app, I selected a 15-minute "Mindful & Chill" quest card on my PC, put my desktop on sleep mode, and went for a loop around my neighborhood.

The app tasked me with observing sunlight patterns through tree leaves and collecting 5 distinct leaf shapes without looking at my phone. Having the AI generate a structured, lightweight physical task made stepping away from my workstation effortless—the screen time took under 30 seconds, and I spent the next 20 minutes completely offline.

Hello DEV! 👋 Intro & My Path into Data Science

Riya Dhami — Wed, 07 Oct 2026 03:29:46 +0000

Hey DEV community!

I wanted to drop a quick hello to introduce myself. I’m Riya, an engineering student passionate about software, data, and building things from scratch.

What I’m currently working on & learning:

🐍 Python & SQL: Focusing heavily on data analysis, dataset visualization, and database logic.

⚙️ Systems & Web: Building tools in C and interactive web graphics using JavaScript.

📦 Building in Public: Documenting my project builds and contributing to open-source events.

I joined DEV to share what I’m building, learn from experienced developers, and track my progress as I transition deeper into Data Science.

Looking forward to connecting! What projects or technologies are you currently excited about? 💻✨