Piyush
Mishra

What it does

Provides a canonical, graph-structured runtime model of web apps, desktop software, and backend services that yields identical SHA-256 hashes for the same input across Python, TypeScript, Dart, Java, and Kotlin SDKs. The system captures DOM events, state machines, and network traffic, then stores them in a deterministic intermediate representation that can be replayed or reconstructed. SDKs expose the model and cryptographic identity via Kaalka v5 encryption.

Why it exists

Existing scrapers and automation tools cannot reliably handle dynamic, authenticated, and stateful software, making auditing and AI-driven interaction brittle. The platform enables reliable replay and reasoning for both human engineers and autonomous agents.

What it does

Provides real-time speech transcription and AI-generated answers during calls. Built with JavaScript, HTML and Node.js in a cross-platform desktop runtime, it routes audio to transcription providers and queries LLM backends via OpenAI-compatible APIs. Users configure providers and models through an in-app settings UI.

Why it exists

Created to give meeting participants instant notes and on-demand answers without leaving the call.

What it does

Provides a FastAPI web API and a Discord bot that automate GitHub organization tasks using Groq LLMs. The Python code runs as separate web and worker processes, selectable via Render or a single-container Docker deployment, and includes health checks, email reporting, and state persistence.

Why it exists

Built to reduce manual admin effort by letting an AI select appropriate models for tasks, report activity, and expose controls through Discord and HTTP endpoints.

What it does

A Python service that captures spoken questions via microphone or system audio, sends the transcription to Google Gemini, and renders the response in a borderless, always-on-top overlay window. It uses Windows APIs to hide the overlay from screen capture and provides a global hotkey to show or hide the UI. The implementation relies on google-genai, speech_recognition, pyaudio, keyboard and requests libraries.

Why it exists

It provides hands-free, instant answers without disrupting the user's workflow, addressing the need for quick information retrieval while working on other applications.

What it does

Provides code completion and suggestion functionality for several programming languages. Built entirely in Python, it trains a language model and serves predictions through a web API, with a lightweight web interface for interactive use.

Why it exists

Created to give developers faster, context-aware coding assistance without leaving their editor.

What it does

The app accepts PDF proposals, extracts key sections such as Technical Approach and Past Performance, and assigns scores using either heuristic calculations or the Google Gemini API. Scores are combined to produce a ranked list displayed with visualizations and downloadable reports. It is built with Streamlit for the UI, Python for processing, and SQLite to store the Gemini API key locally.

Why it exists

Automates the initial assessment of proposal documents, reducing manual review time and providing consistent scoring.

What it does

Provides three independent recommendation systems—financial advice, health alerts, and learning guidance—implemented in Python 3.10+. Each uses rule-based analysis (and optional ML for learning advice) and offers both command-line execution and a Streamlit web UI, with PDF export for finance and batch CSV processing for health.

Why it exists

Built to showcase domain-agnostic AI advice generation and interactive delivery without external services beyond optional Gemini API integration.

What it does

Provides a suite of activities—text cleaning, emotion classification, summarization, and entity checking—through a unified Python codebase. The pipeline is organized in Jupyter notebooks and packaged as a Docker container for reproducible execution. Users can run the service locally or via the provided Docker image.

Why it exists

Creates a single entry point for preprocessing and extracting insights from arbitrary documents, reducing the need to stitch together separate tools.

What it does

Provides a set of Jupyter notebooks and command-line tools for DNA sequence analysis, bioactivity prediction, solubility estimation, and molecular descriptor calculation. The environment is containerized with Docker and combines Python scripts with Java components to run consistently across systems.

Why it exists

Creates a single reproducible workspace for students and researchers to explore multiple bioinformatics tasks without manual setup of dependencies.

What it does

Provides stock, real-time, MPG, and generic data visualizer dashboards built with Python and Streamlit. The codebase includes Jupyter notebooks for exploratory analysis and is packaged in a Docker image for consistent execution.

Why it exists

Created to give analysts a single, reproducible environment for exploring and visualizing financial data without manual setup.

What it does

A set of Jupyter notebooks that implement machine-learning pipelines for four tasks: stock-market price forecasting, wine-quality classification, personalized-medicine recommendation, and retail-store product recommendation. The notebooks use Python libraries for data cleaning, feature engineering, model training, and evaluation.

Why it exists

The internship required applying data-science techniques to real-world problems across finance, agriculture, healthcare, and retail domains.

What it does

It provides book search via Google Books and Open Library APIs and generates recommendations using a collaborative-filtering model trained on user ratings. The front end is built with Streamlit, while data handling uses Pandas and the model uses the Surprise library, persisted with Pickle. The app runs in a Docker container.

Why it exists

It was built to let users discover books tailored to their preferences without manual curation.

What it does

Builds a model that predicts a student’s placement outcome from CGPA and IQ using a RandomForestClassifier with hyperparameter tuning. The model is served through a Streamlit web interface where users enter their scores and receive a prediction. The entire stack is containerized with Docker for consistent deployment.

Why it exists

Provides a quick, data-driven estimate of placement likelihood for students without manual analysis.

What it does

A Streamlit application that lets users enter medical measurements and returns a benign or malignant classification with probability. The prediction uses a pre-trained logistic regression model on the Breast Cancer Wisconsin dataset and runs inside a Docker container.

Why it exists

Provides a quick, interactive way to explore model predictions without writing code, demonstrating end-to-end ML deployment.

What it does

Builds a web app that returns five movies most similar to a selected title using cosine similarity on genre, cast and overview features. The recommendation engine runs on pandas and scikit-learn, while Streamlit renders the interactive interface and fetches posters via the TMDb API. The service is containerized with Docker for easy deployment.

Why it exists

Provides a quick way for users to discover movies with comparable content and visual context, reducing manual search effort.

What it does

The script reads a CSV containing Binance trade histories stored as JSON-like strings, parses them into structured records, and computes financial indicators such as ROI, PnL, Sharpe Ratio, maximum drawdown, and win rate. It then normalizes these metrics, applies a weighted scoring model, and outputs two CSV files: a full metrics table and a ranked list of the top 20 accounts. The implementation uses Python with pandas for data manipulation and NumPy for numerical calculations.

Why it exists

Traders and analysts need a repeatable way to evaluate large volumes of trade data and compare account performance across multiple risk-adjusted dimensions.

What it does

Provides a time-driven encryption protocol that creates unique ciphertexts tied to a specific timestamp. Implements envelope, seal, replay protection, and chunked file encryption, exposed through a JavaScript web demo and a multi-language CLI. The core logic is written in JavaScript and duplicated in Python, Java, Kotlin, and Dart with unit tests ensuring identical behavior.

Why it exists

Enables secure communication that expires or becomes invalid outside its intended time window, mitigating replay attacks and simplifying cross-platform key management.

What it does

A local server receives all device requests, encrypts traffic end-to-end, and forwards it through a proxy that masks the external IP. It assigns a unique hash to each device and router, using the hash table for packet routing. Traffic is passed to a one-dimensional convolutional neural network that classifies packets as benign or malicious before reaching the internet.

Why it exists

Increasing packet-level cyber attacks require a gateway that secures internal traffic and hides device identities when accessing external networks.

What it does

The tool embeds an encrypted text payload into a bitmap using least-significant-bit steganography and extracts it back to plain text. It is written in Java with a thin Shell wrapper to invoke the Java classes from the command line. Encryption of the payload uses standard AES before embedding.

Why it exists

It provides a way to hide confidential information inside ordinary images without requiring external services.

What it does

A desktop text editor that requires users to log in before editing files. Credentials are hashed with SHA-256 and stored, preventing plain-text passwords. The application is written primarily in Java with supporting shell scripts and Python utilities for build and testing.

Why it exists

Provides a simple editing tool while ensuring password data is protected using cryptographic hashing.

What it does

A WhatsApp-style messaging service that encrypts both transmission and local storage with a custom dual-layer Kaalka v5.0.0 algorithm. The backend is a FastAPI server written in Python, while the UI is built with Flutter (Dart) and integrates Kaalka via WebAssembly. Native C++/Swift bindings provide the same encryption on mobile and desktop clients.

Why it exists

It was created to achieve cryptographic sovereignty by eliminating all external crypto libraries and providing end-to-end protection across platforms.

What it does

SHE is an interpreted language written in Python that provides a simple syntax for arithmetic, variables, conditionals, loops, functions, strings, and lists. The interpreter includes a REPL and a script runner that execute .she files. Built-in functions expose the Kaalka encryption package for message encryption and decryption.

Why it exists

It offers a lightweight teaching tool for newcomers to programming while demonstrating how to embed cryptographic primitives in a language runtime.

What it does

Provides /encrypt and /decrypt endpoints that apply time-based encryption using the Kaalka library. Built with async FastAPI, it streams files in memory and validates input with Pydantic. A background task removes temporary files every 60 seconds and the service is containerized via Docker and includes a Streamlit test UI.

Why it exists

Offers developers a simple HTTP interface to secure messages and files with timestamp-bound keys, avoiding custom cryptography implementations.

What it does

A service that extracts job postings from iCIMS career portals. It uses Playwright to render JavaScript-heavy pages and falls back to BeautifulSoup for static content. The scraper is exposed via a FastAPI REST endpoint and a command-line interface, and the whole application is containerized with Docker.

Why it exists

Organizations need a reliable way to programmatically collect job listings from iCIMS sites that often require browser automation. The project provides an automated, reusable solution.

What it does

Provides a web interface for creating, reading, updating, and deleting user records stored in a MySQL database. Implemented with JSP for view rendering, Servlets for request handling, and JDBC for database access, packaged as a Maven web application.

Why it exists

Built to illustrate end-to-end CRUD operations in a Java web stack.

What it does

Provides a RESTful service exposing create, read, update, and delete endpoints for data stored in MongoDB. Implemented with Spring Boot and Spring Data MongoDB for persistence, and Spring MVC for request handling. Includes basic front-end assets and build scripts.

Why it exists

Created to offer a reusable backend component that projects can integrate for database interaction without building their own service layer.

What it does

A database management system built in Python that supports distributed operation. It includes a custom schema design, data replication across nodes, and a query optimizer. The codebase consists of 31 commits authored entirely by the engineer.

Why it exists

Provides a lightweight, high-performance alternative for applications needing distributed storage without external dependencies.

What it does

Provides APIs for user sign-up, plan subscription, invoice generation and payment. Implements Django models for User, Plan, Subscription, and Invoice, and uses Celery to run daily tasks that create invoices, mark overdue items and print reminders. Includes a mock Stripe PaymentIntent endpoint to record payments.

Why it exists

Needed a lightweight system to manage recurring subscriptions and automate billing cycles without relying on external SaaS solutions.

What it does

A web application that lets users upload .txt, .pdf, .docx, and .md files, then ask natural-language questions and receive AI-generated answers with inline citations. The pipeline chunks documents, creates embeddings with Google Gemini, stores vectors in Pinecone, applies MMR retrieval and Cohere reranking before generating responses via Groq’s Llama-3.3 model. The front end shows real-time timing, token usage, and cost metrics.

Why it exists

Provides a low-cost, end-to-end solution for extracting information from heterogeneous user documents while preserving source provenance.

What it does

The site renders a moonlit arcade corridor in the browser where each photograph hangs on a wall. Users can scroll, walk with WASD, or click frames to view full-resolution images. The build pipeline watches the photos folder, resizes images, extracts colors, runs an AI model to generate titles and captions, and redeploys via GitHub Actions without a separate framework.

Why it exists

Typical photography sites display images in a static grid; this project creates an interactive spatial experience that showcases photos as part of an environment.

What it does

A Java-based desktop program that lets users exchange messages instantly over a network. It uses Java sockets for real-time communication, stores chat history in MySQL via JDBC, and encrypts messages before transmission. The UI is built with Swing and the project can be compiled in any standard Java IDE.

Why it exists

Provides a lightweight, secure way for systems on a LAN to chat without relying on external services.

What it does

Provides a web UI for receptionists to register patients and perform CRUD on records, and for doctors to view and update patient details. Built with Go’s net/http server, PostgreSQL for persistence, and a Tailwind-styled HTML/JS front-end. Authentication uses JWT and role-based access control.

Why it exists

Created to replace manual paper-based patient tracking with a centralized digital system.

What it does

The site presents travel content with a layout that adjusts to phones, tablets, and desktops. It is built with semantic HTML, SCSS for modular styling, and vanilla JavaScript for interactive elements. All assets are compiled and deployed via simple shell scripts.

Why it exists

Created to provide a mobile-friendly travel information portal without relying on external frameworks.

What it does

Provides a graphical editor with syntax highlighting where users can type Python code and run it with a single click. The application is written in Python and uses a shell wrapper to invoke the local Python interpreter. Execution results are shown in an integrated output pane.

Why it exists

Creates a lightweight alternative to heavyweight IDEs for quick script development and testing on a local machine.

What it does

The service lets users register, log in, and create, edit, or delete blog posts. It is built with React for the front end, Express and Node.js for the API, and MongoDB for persistence. Authentication uses JSON Web Tokens and the UI is styled with CSS and HTML.

Why it exists

Provides a simple platform for users to publish personal content without relying on third-party services.

What it does

The project provides a self-hosted web browser that loads and displays web pages. It is written primarily in Python and packaged with a Dockerfile for isolated execution. The code includes navigation logic and basic HTML rendering capabilities.

Why it exists

It was created to explore browser fundamentals and to have a lightweight, personal browsing tool.

What it does

A web service that registers users and agents, then pairs them based on shared interests and expertise. Built with Flask for the backend, MongoDB for data storage, and Jinja2 templates styled with Bootstrap. Deployed in a Docker container for reproducible hosting.

Why it exists

Provides a community-focused way to discover relevant agents, reducing friction in collaboration and mentorship.

What it does

A service that parses PDF resumes, extracts skills and experience, matches them against job requirements, and returns a suitability score. Built with Python and packaged in a Docker container, it includes a web interface for uploading resumes and entering requirements.

Why it exists

Automates the first-screen of candidates, reducing manual review time for recruiters.

What it does

The repository contains two web applications—a blog site for publishing and reading posts and a video-conferencing interface for real-time calls. Both are built with JavaScript, HTML, and CSS and were assembled during a short internship period.

Why it exists

The projects were created to satisfy assigned tasks for the Bharat Intern program and to gain practical front-end development experience.

What it does

The application lets users upload an Excel file containing phone call records, edit call status fields, add free-form notes, and view summary statistics in interactive Plotly charts. It is built with Streamlit for the UI, Pandas for data handling, and Plotly for visualizations, and runs inside a Docker container.

Why it exists

It provides a lightweight tool for tracking call outcomes without needing a separate CRM system.

What it does

A public website displays every repository in the organization, fetching a snapshot from a JSON file and then augmenting it with a single unauthenticated GitHub API call. A daily GitHub Actions workflow runs an LLM to write summaries for changed repositories and writes them to data/repos.json. The site uses plain HTML, CSS and JavaScript, served directly from GitHub Pages with no build step.

Why it exists

It provides an up-to-date, human-readable overview of the organization’s projects without manual maintenance.

What it does

A web app that lets users add, edit, and delete financial transactions, organize them into predefined categories, and set monthly budgets. Built with React and TypeScript, it uses Tailwind CSS for styling, shadcn/ui components, Recharts for charts, and Zod for form validation.

Why it exists

It addresses the need for individuals to monitor spending, compare actual expenses against budgets, and visualize financial health.

What it does

A basic React application that renders a "Hello World" page. The app is containerized with Docker, built and pushed via GitHub Actions, and deployed automatically to Render.

Why it exists

It demonstrates a minimal end-to-end pipeline so code changes are built, containerized, and published without manual steps.

What it does

A dashboard that displays live financial transactions, historical data with filtering and pagination, and summary charts. The frontend is a React/TypeScript app styled with Tailwind CSS, using Chart.js for visualizations and Axios for API calls, receiving updates through WebSocket. The backend is a Node/Express service backed by MongoDB, authenticates users with JWT, and pushes transaction events via WebSocket.

Why it exists

Provides users immediate visibility into transaction flow and aggregate metrics without manual refresh.

What it does

Provides a web interface to start, pause, and stop crawls while showing live statistics and activity logs. The backend runs a Node.js crawler that respects robots.txt, limits depth, and throttles requests, communicating updates via Socket.IO. The frontend uses Tailwind CSS and vanilla JavaScript to render a responsive dashboard.

Why it exists

Built to give developers visibility into crawling progress and control over parameters without needing command-line tools.

What it does

A static website that presents a real-estate property for KDM Property Consultancy. It uses HTML for structure, CSS for styling and layout, and vanilla JavaScript for basic interactivity. The page adapts to different screen sizes via responsive design techniques.

Why it exists

The consultancy needed an online presence to showcase a property without a full CMS or backend. The site provides a quick, accessible view for potential clients.

What it does

The service fetches live flight data from the OpenSky Network API, filters it for Australian routes, and sends the data to the Gemini API to generate textual insights on demand and pricing. It renders interactive Plotly charts and the generated insights in a Flask-served HTML interface. Asynchronous calls and exponential-backoff retry logic keep the UI responsive despite external API latency.

Why it exists

Airline analysts need up-to-date demand and price trends without manually aggregating flight data. The app automates data collection, analysis, and visualization in a single web portal.

What it does

Provides a dynamic list of blog posts fetched from an external REST API, with pagination, sorting, search, and a related-posts section. Implemented with Java Sling Models, OSGi configuration, and a servlet for data access, while the front-end uses HTL, vanilla JavaScript, HTML and CSS. Includes JUnit tests for backend logic and follows WCAG accessibility guidelines.

Why it exists

Needed a reusable, configurable blog list component in AEM that could display external content with rich interaction and meet accessibility standards.

What it does

A web application that lets administrators add, view, and delete room records and lets users register, log in, browse available rooms, make bookings, and cancel them. Built with Flask for routing and business logic, HTML/CSS templates for the UI, SQLite for data storage, and Werkzeug for password hashing.

Why it exists

Created to provide a single interface for hotel staff and guests, reducing manual paperwork and coordinating room availability in real time.

What it does

Provides a reusable OAuth2 client that supports Auth0, Clerk, and Kinde, handling PKCE, token storage in HTTP-only cookies, automatic refresh, and user profile retrieval. The library is written in TypeScript and is demonstrated in a Next.js 13 application styled with Tailwind CSS and shadcn/ui components.

Why it exists

Simplifies secure OAuth integration for web apps while keeping the API type-safe and provider-agnostic.

What it does

The app lets farmers capture a crop photo, uploads it, and runs a trained machine-learning model to classify the disease. If the model’s confidence exceeds 51 % the app shows the disease name and symptoms; otherwise it queries a general solution repository and logs the image for expert review. The workflow includes OTP-verified registration, offline operation, and a chat channel to contact specialists.

Why it exists

Farmers need rapid, low-cost diagnosis of crop diseases without requiring specialist visits.

What it does

The app retrieves current articles from newsapi.org and lets users select from multiple news categories. It is written in Java for Android and uses Retrofit for network calls, Picasso for image loading, and RecyclerView for list presentation. The source includes a configurable API key placeholder for deployment.

Why it exists

Provides a simple mobile interface to browse up-to-date news without needing a web browser.

What it does

Provides basic editing features such as filters and adjustments. Built with a Java UI layer and RenderScript kernels for pixel-level processing.

Why it exists

Created as an educational project to practice Android image-manipulation techniques.

What it does

Builds an Android app that captures camera frames and extracts barcode or QR data in real time. The app is written in Java and integrates Google ML Kit for fast, on-device barcode recognition. Scanned results are shown on a simple UI.

Why it exists

Provides a lightweight, offline solution for reading barcodes and QR codes without third-party services.

What it does

A set of five Android applications—unit converter, to-do list, calculator, quiz, and stopwatch—built in Java using the Android SDK. Each app follows standard activity lifecycle patterns and uses XML layouts for UI.

Why it exists

The apps were created to satisfy internship requirements for designing and developing Android applications and to practice core mobile development skills.

What it does

A notes application for Android that lets users create, edit, delete, and tag notes. Built in Kotlin using Android Studio and the Android SDK, it presents a clean UI for managing note entries. The codebase is fully Kotlin with supporting shell scripts for build automation.

Why it exists

Provides a lightweight, on-device solution for quick note taking and organization without relying on external services.

What it does

The app retrieves the newest memes from Reddit and presents them in a scrollable list on Android devices. It is written in Kotlin and built with Android Studio, using standard Android SDK components to perform network calls and render images. Users can open a meme detail view and invoke Android’s share intent to distribute the content through other apps.

Why it exists

It offers a quick way for mobile users to browse and share Reddit memes without leaving their device.

What it does

The app lets a user enter a city name and displays current temperature, condition, humidity, and wind speed. It calls the OpenWeatherMap REST endpoint, parses the JSON response, and updates the UI. The UI is built with Flutter widgets and shows a loading indicator and error messages.

Why it exists

It provides a quick way to view live weather information on a mobile device without leaving the app.

What it does

Builds a Docker image based on Ubuntu that installs Python 3, OpenJDK 11, Android SDK, ADB, QEMU-KVM and related libvirt tools. The image creates an Android Virtual Device (API 30) and configures KVM permissions, then runs a Bash shell that can be used by a web front-end to upload APKs and display the app inside the emulator. The setup is scripted entirely in a Dockerfile and supporting shell scripts.

Why it exists

Enables testing of Android applications without enabling unknown-source installs on physical devices, allowing developers to run and view apps directly from a browser.

What it does

A minimal kernel that outputs a static message at boot. It combines Assembly boot code with C initialization, compiled via a Makefile. The build runs inside a Docker container to provide a consistent environment.

Why it exists

Created to explore low-level system programming and kernel boot processes.

What it does

The assistant listens for spoken commands, maps them to predefined actions, and executes tasks such as retrieving the time, searching the web, playing music, or sending email. It is written in Python, uses speech-recognition libraries for audio input, and calls external services via HTTP or system calls. An optional OpenAI key enables ChatGPT-style conversational responses through the E.T.E.R.GPT module.

Why it exists

It provides a hands-free way to perform frequent computer tasks, reducing manual interaction for the user.

What it does

A static site that displays recruiter-facing narratives for every public repository. A GitHub Action scans the account, queries the GitHub API, and uses a free OpenAI-compatible LLM to write the narratives, committing them to data/portfolio.json. The site is generated from that JSON with TypeScript, JavaScript and CSS.

Why it exists

Manually updating a portfolio is time-consuming and error-prone; the automation keeps the content current and consistent.

What it does

The service generates a short concept with Gemini, writes a script, creates a TTS voiceover via edge-tts, produces captions, builds a thumbnail, assembles the video using MoviePy, and uploads it to YouTube. All steps are orchestrated in Python and run as a Render-hosted containerized job. Temporary files are deleted after upload to free disk space.

Why it exists

It automates the manual workflow of producing YouTube Shorts, shrinking the time from idea to published video to a few minutes.

What it does

Provides a configurable menu to run common Git commands from the project’s working directory. Implemented as a Bash wrapper that invokes Python for command handling and state persistence. The script is installed once per repository and reused without further setup.

Why it exists

Reduces repetitive typing of Git commands and eliminates manual configuration when switching projects.

What it does

Provides a command-line menu that runs common Git commands and Docker build/push workflows from a project directory. Implemented as a Bash wrapper (dash.sh) that invokes Python helpers for configuration and Dockerfile generation. Distributed as a Docker image for consistent execution across environments.

Why it exists

Reduces manual repetition of version-control and containerization steps, especially for developers switching between projects or using WSL on Windows.

What it does

Provides a terminal menu to run common Git commands (add, commit, push, pull, branch) from a configured project folder. Implemented as a Bash script with supporting Python helpers, it reads a config file and executes the selected operation. The script is intended to run under WSL on Windows or any Linux shell.

Why it exists

Reduces manual typing of repetitive Git commands and ensures consistent workflow across projects.

What it does

A Python service fetches trending tech topics from six public APIs, then uses a Groq LLM to create an 11-scene script. It generates images with Stable Diffusion XL, voice-overs with Kokoro TTS, and subtitles via OpenAI Whisper, composes the video with MoviePy, and uploads it to YouTube using OAuth 2.0. The workflow can run daily on a schedule and cleans up temporary files automatically.

Why it exists

Manually producing daily tech videos is time-consuming; the system creates and publishes content automatically to maximize viewership and monetization.