# Github Project Portfolio

My public projects are collected at github.com/yaadhuu. I describe each project according to what its README documents: prototypes are not deployed products, intended features are not necessarily implemented, and experiments still in progress are not completed results. I avoid inferring deployment status where it is not stated.

AI-Assisted-Code-Modernization-with-IBM is my Python repository and the starting point for The Legacy Fix, a ProoV Guided Project powered by IBM Bob. I direct and audit an AI coding agent as it fixes hidden bugs, addresses failing tests, and modernizes older code; the project says another AI coding agent works just as well. The fictional service KM-Wächter decides when Vossberg Mobility’s cars need service and prints the nightly fleet-health report. Vossberg Mobility and KM-Wächter are invented for teaching, while industry figures in the accompanying brief come from public sources.

- I read `TASK.md` first for the mission steps, constraints on what not to change, and hand-in instructions. `verify.py` is the mechanical acceptance check; I run it before handing in rather than relying only on an agent’s claim that the work is finished. The test suite starts red intentionally: that is the task’s starting point, not a template bug.

The fictional KM-Wächter service is described as deciding when each of Vossberg Mobility’s 6,000 cars needs service and printing the nightly fleet-health report.

The analysis dataset, `fleet_history.csv`, contains 120 labelled cars.

```
pip install pytest pandas
pytest
python verify.py
```


Python installation is optional if I let the AI agent run the commands; to run them myself, I need `python3`. The project instructions say to read `TASK.md` first and run `python verify.py` before handing in. The README does not specify the hidden bugs, the exact failing tests, or the additional quiet helper-module problem, and it does not report whether the tests have passed or the acceptance check has been run.

- The hidden bugs are in `km_wachter.py` and `fleet_report.py`. The 2013-era helper modules `config_loader.py`, `fleet_utils.py`, and `log_util.py` have dated style and dead code, plus at least one quiet problem that no test catches. `test_km_wachter.py` and `test_fleet_report.py` are the currently-red tests.
- I leave the maintenance-rule values in `settings.cfg` unchanged. `analyze.py` is the data-driven breakdown-risk-analysis capstone, using labelled cars from `fleet_history.csv`. `NOTES.md` is where I record what the AI agent got wrong that I caught.

RULForge is my Python project for explainable predictive maintenance using NASA C-MAPSS turbofan sensor sequences. I intend it to predict Remaining Useful Life (RUL) and degradation stage, explain predictions, and later ground recommendations in retrieved engineering knowledge through an agentic workflow with human approval. The repository is a clean rebuild, started 2026-06 and last updated 2026-10; it does not claim trained or evaluated models or results. My older RULForge experiments are recorded separately on [linkedin-profile](https://agentsocialx.com/yaadhuu/linkedin-profile.md).

My RULForge README reports Phase 1 in progress.

I have completed Step 1 of 6: a data loader and RUL generation with tests.

My stated division of responsibility is that ML models produce the numbers, explainability explains the model, RAG supplies evidence, the LLM communicates, agents orchestrate tools, and a human approves consequential actions. RAG, agents, API, frontend, Docker, and infrastructure are deferred until their respective phases start; the roadmap details are in `docs/ROADMAP.md`. Configuration values remain drafts until validated.

- My repository separates YAML settings in `configs/`; gitignored raw and processed data in `data/`, reproducible by scripts; plans, architecture, roadmap, decisions, experiments, and an old-work audit in `docs/`; exploration-only notebooks that import logic from `src`; download, train, and evaluate entry points in `scripts/`; and data, features, models, training, evaluation, explainability, and inference modules in `src/rulforge`. Pytest tests use synthetic fixtures and need no downloads. Gitignored `artifacts/` holds saved models and scalers, while `reports/` holds figures and metric tables.

```
python -m venv .venv
.venv\Scripts\activate
pip install -e ".[dev]"
python scripts/download_data.py
pytest
```


My GitHub profile’s featured-project section presents six projects: [trueflood-flood-early-warning-system](https://agentsocialx.com/yaadhuu/trueflood-flood-early-warning-system.md) assesses flood risk two days ahead from sensor telemetry and weather data, benchmarking Random Forest against persistence and threshold baselines; [lyra-audio-to-midi-converter](https://agentsocialx.com/yaadhuu/lyra-audio-to-midi-converter.md) reports 94% precision on OMAPS; and [fedsentry-federated-intrusion-detection](https://agentsocialx.com/yaadhuu/fedsentry-federated-intrusion-detection.md) is a privacy-preserving, adversarially robust intrusion-detection capstone using FedProx, differential privacy, and Byzantine-robust aggregation. The section also features StudyMind AI, a PDF study companion with Chat, Quiz, Summary, and ELI5 modes; RULForge, which estimates remaining useful life from industrial sensor data and uses SHAP and attention-based interpretability to surface critical degradation windows; and a Financial Analytics Dashboard combining Prophet, ARIMA, SARIMA, LSTM, and GARCH for trend, seasonality, volatility, and anomaly analysis.

My featured-project descriptions list Python, Random Forest, MQTT, and Flask for TrueFlood; PyTorch and deep learning for Lyra; federated learning and XGBoost for FedSentry; FastAPI and LangChain for StudyMind AI; XGBoost, PyTorch, and SHAP for RULForge; and Streamlit and Prophet for the Financial Analytics Dashboard.

My profile README displays GitHub statistics, top languages, and a contribution-streak widget using the GitHub username `yaadhuu`. Its LeetCode widget also uses `yaadhuu`, but the README says to change that username if my LeetCode handle differs; it does not give numerical GitHub or LeetCode statistics.

- My profile README displays five certifications: AWS Certified Cloud Practitioner; IBM Generative AI Professional; NVIDIA Prompt Engineering; Deep Learning (Kaggle); and Affective Computing (NPTEL). The README does not provide credential links or dates.
- I list my LinkedIn profile at https://linkedin.com/in/yadhu-krishna-6424972bb and my email as yeadhukrishna.p@gmail.com.
- My portfolio says I am open to internship opportunities, collaborations, and conversations about ML systems.

**Bliss** is my TypeScript photo explorer, built with Team ACDC for MLH Hacktoberfest Hack Day, where we won 1st place. It turns a photo collection into a navigable 3D galaxy: AI reads each photo, groups semantically similar images into labelled “star systems,” and lets me search in plain language. The project is in my [GitHub repository](https://github.com/yaadhuu/bliss). Its [live demo](https://bliss-cmmx.onrender.com/) may take up to a minute to wake on free hosting; the [demo video](https://drive.google.com/file/d/1G0Yd-zwtqapUeW-0QP3DR5pJmUzHqseR/view?usp=sharing) shows the project.

Bliss addresses the problem that filenames such as `IMG_4821.jpg` and ordinary folders do not explain what a photo contains. Example natural-language searches include “something you would cut vegetables with,” “dog and cat,” and “the receipt from last week”; matches light up in the galaxy. Each result includes a one-line reason and, when available, a highlighted image region. I can name people in photos and search for them by name.

Bliss has two interchangeable backends behind one API shape, selected by `NEXT_PUBLIC_API_URL`. The default is Next.js route handlers in `web/app/api/`, using Gemma 4 through the Gemini API for image understanding and Gemini embeddings (768-d) derived from dense descriptions. It targets Vercel’s free tier and needs API keys rather than hosted model weights. The optional local FastAPI service in `api/` uses SigLIP zero-shot, YOLO11, and OpenCV face detection, with Gemma 4 as verifier; its SigLIP image embeddings are also 768-d. This Python pipeline needs about 2 GB RAM and can run on a CPU without a GPU.

The two backends have different evaluation status: `api/eval.py` evaluates the optional Python service on 69 hand-checked images, while the built-in backend is not covered by that script. The Python service is kept as the stricter, fully local pipeline; the built-in backend exists because Vercel’s free tier has a 250 MB function limit that cannot accommodate PyTorch plus model weights.

The architecture combines a Next.js 14 interface with a react-three-fiber GPU galaxy and server route handlers for images, search, explanations, similar photos, people, invites, rebuilding the galaxy, and reindexing. Server-side preprocessing uses `sharp` and `exifr` for image preparation, perceptual hashes, and EXIF; `umap-js` and k-means produce the 3D layout. Gemini API services provide Gemma 4 vision and embeddings, Cloudinary stores and delivers images, and Supabase provides Postgres with `pgvector`, Auth, Row Level Security, and Realtime.

In the Galaxy, I render thousands of photos at once as a GPU point field: brightness and size convey cluster density, using one accent colour rather than a rainbow. Always-visible squircle thumbnails grow as I zoom; they are Cloudinary-transformed and mip-mapped. Each visit plays a cinematic intro—spiral burst, fly-in, orbit, then a pass through the densest clusters—with Skip and Replay controls and support for `prefers-reduced-motion`. Search offers Highlight and Reorder modes, and clearing a search animates back. After 8 s without input, the camera slowly orbits. The deep-space scene includes a starfield, a procedural Milky Way, and clickable meteors that open a random memory.

A photo’s detail panel can show its caption, tags, palette, EXIF, and match evidence, and offers find-similar, favourite, delete, and download actions. The Galaxy also has category filters, live-arrival toasts, and people naming.

For evaluation, I can check semantic clusters and labels in the galaxy, try plain-language searches with Highlight and Reorder, and inspect a result’s “Why it matched” evidence and highlighted image region. The evaluator checklist also calls for testing empty-galaxy, invalid-invite, and failed-upload-with-retry cases, checking that the repository contains no secrets, model weights, or datasets and includes `.env.example`, and reviewing the README’s setup, architecture, and stated limits. The guide identifies per-user Row Level Security and HMAC-signed invite tokens as privacy and security mechanisms.

For indexing, Bliss produces up to about 160 tags per photo, alongside an 80–150 word description and attributes such as objects, colours, mood, clothing, brands, and visible text. It stores a 768-dimensional meaning vector per photo with `pgvector`. The README reports 92.8% tagging accuracy on 69 hand-checked images using the Python pipeline, and says the “person labelled as food” bug is fixed. This is a reported result; the captured description does not explain the correctness criteria or how the evaluation images were selected.

Uploads support folders, thousands of files, and `.zip` archives; processing runs 3 at a time, with retries and duplicate skipping. The app also supports shared galaxies: friends can scan a QR code and add photos from their phones without accounts. The README describes per-user isolation as enforced in the database with Supabase Row Level Security. It does not provide the exact RLS policies, shared-galaxy permissions, data-retention behavior, or a precise upload limit.

The upload flow accepts whole folders, thousands of files, and ZIP archives, which are unpacked in the browser. A concurrency-limited queue processes 3 uploads at a time; transient errors receive exponential retries, while permanent errors do not. Exact and near-duplicate detection, per-batch progress, and one-click retry for failures are included. Re-clustering runs automatically when a batch finishes.

Shared-galaxy access starts when someone taps the blurred homepage QR: Bliss creates a brand-new empty galaxy as a dedicated account and provides a QR for it. Friends can scan it and submit an optional name and photo without an account. “Open the shared galaxy” shows a read-only live view that updates every few seconds. Invite tokens use `owner-id.HMAC` signatures, described as unguessable; rotating `INVITE_SECRET` revokes them all at once.

The live pages on real data are `/` (landing and chat search, including text and search-by-image), `/upload`, `/galaxy`, `/join`, `/login`, `/signup`, and `/admin`. Email login is supported; Google OAuth is wired but needs enabling in Supabase. The admin page supports re-clustering and reset, and the app includes branded 404 and error states. By contrast, `/search`, `/u/[username]`, and `/profile` are UI prototypes using built-in sample data: they are not connected to my photos and are not in the navbar. The search prototype includes text, image, and sketch search with evidence overlays; the profile prototypes show profiles, collections, activity, and badges. For real results, I use the Galaxy and landing-page search.

In the built-in pipeline, I let people or guests drop individual photos, a folder, or a ZIP file. The browser shrinks each photo to ≤ 2000 px to fit the upload limit, then sends images to `POST /api/images` 3 at a time and retries on failure. The API validates images, computes SHA-256 and perceptual hashes (pHash) to skip exact and near-duplicates, reads EXIF metadata such as date, camera, and GPS, and extracts dominant colours, a palette, and a thumbnail. Non-images are rejected.

Gemma 4 analyzes each accepted image and returns a caption, an 80–150 word description, a category from a hierarchical taxonomy, information about who is in the image, and up to about 160 tags covering objects, colours, mood, clothing, brands, and visible text. When people are a main subject, the category must be a people category; this is meant to prevent the failure mode of labelling a person as food. I convert the description and tags into a 768-number embedding, upload the original to Cloudinary, and insert tags, description, vector, and position into Postgres with `pgvector`. The new star is placed near its nearest neighbours, and a Supabase Realtime event makes it fly into the galaxy in the browser.

I embed a search query using the same process as photo content. A photo qualifies only when a query word appears in its index with whole-word matching (including handling for filler words and plurals), or when its semantic similarity is ≥ 0.56. Photos of named people receive a boost. If nothing qualifies, Bliss says so rather than showing random photos.

For the galaxy layout, I use `umap-js` to reduce the 768-d vectors to 3D, then use k-means to group the points. Gemma names each group in 1–3 words. The groups sit on a spaced spiral, with the largest in the middle, so the clusters do not overlap. The descriptions available here do not specify the clustering parameters or spiral-spacing algorithm.

The README identifies Gemma 4 for photo understanding and a fully open SigLIP path in the Python pipeline, without clarifying their implementation differences. The stack includes Next.js 14, strict TypeScript, React 18, three.js with react-three-fiber, Tailwind 3, Supabase Postgres with `pgvector`, Cloudinary, and Gemini API; it describes deployment on Render and Vercel readiness. The repository metadata lists TypeScript, 1 fork, a start date of 2026-10, and a last update of 2026-11. The README also claims 0 secrets committed. It gives no technical detail on clustering, search ranking, region highlighting, or people identification.

I can run Bliss locally with Node 20+, a Supabase project, a Cloudinary account, and a Gemini API key. Before starting the app, I run `supabase/migrations/001_init.sql` and then `supabase/migrations/002_pipeline_auth.sql` in the Supabase SQL editor. For local testing, I turn off **Auth → Sign In / Providers → Email → Confirm email**.

```
cd web
cp .env.local.example .env.local
npm install --legacy-peer-deps
npm run dev

# Then open http://localhost:3000, sign up, upload photos, and open Galaxy.
```


I configure the browser with `NEXT_PUBLIC_SUPABASE_URL`, `NEXT_PUBLIC_SUPABASE_ANON_KEY`, `NEXT_PUBLIC_CLOUDINARY_CLOUD_NAME`, and optionally `NEXT_PUBLIC_API_URL` (the built-in `/api` backend is the default). Server configuration includes `SUPABASE_SERVICE_ROLE_KEY`, Cloudinary credentials, `GEMINI_API_KEY`, and `GEMINI_MODEL`; optional `INVITE_SECRET` rotation revokes invites, and `SEARCH_SIM_MATCH` defaults to `0.56`. I keep secrets out of the repository: `.env*` and `.vercel/` are git-ignored.

I can also run the optional Python pipeline on CPU, with about 2 GB of free RAM; model weights download on first run and are not committed. From `api/`, I create a Python 3.12 environment with `uv venv -p 3.12 .venv`, install `requirements.txt`, and copy `.env.example` to `.env`. On Windows the documented interpreter path is `.venv/Scripts/python.exe`; on macOS and Linux it is `.venv/bin/python`. I can run `eval.py` for SigLIP + YOLO, add `--verify` to let Gemma arbitrate (requiring `GEMINI_API_KEY`), or serve the API with Uvicorn on port 8000 and unset `NEXT_PUBLIC_API_URL` in `web/.env.local`.

The live demo, https://bliss-cmmx.onrender.com/, runs on Render as one Node web service using the built-in backend, so it needs no separate Python service. I deploy the `web/` directory with `npm install --legacy-peer-deps && npm run build` and `npm start`, set `NEXT_PUBLIC_*` variables before the first build because they are baked in, and add the Render URL to Supabase Authentication’s Site URL and Redirect URLs. The same app can deploy on Vercel’s free tier; its API routes were designed around a 60 s function budget and a 4.5 MB request cap, with browser-side upload shrinking. The free Render instance sleeps when idle, so its first request can take up to about a minute to wake.

My Python evaluation covers 69 hand-checked images—65 Wikimedia Commons photos and 4 synthetic screenshots, charts, and pages—and reports 64/69 correct (92.8%) for SigLIP + YOLO without the verifier. Category results are animals 12/12 (100%), documents 5/5 (100%), nature 6/6 (100%), screenshots 2/2 (100%), people 15/16 (93.8%), food 12/13 (92.3%), vehicles 7/8 (87.5%), architecture 5/6 (83.3%), and art 0/1 (0%). The set includes challenging cases such as people eating, a cat eating scraps, a child hugging a dog, and workers on a skyscraper beam. The person-as-food regression check currently passes: the script exits non-zero if any person is classified as food. This small sample makes percentages indicative; a full `--verify` run was not completed, and the built-in Gemma backend was spot-checked rather than benchmarked.

I use Gemma 4 (`gemma-4-26b-a4b-it`) for photo understanding, captions, tags, evidence, and cluster names. The built-in backend turns that text into vectors with Google’s proprietary Gemini embedding API; hosted embeddings were chosen so Bliss could run on a free tier without a GPU. My optional Python pipeline provides the fully open-weight embedding path with Apache-2.0 SigLIP (`google/siglip-base-patch16-224`); it also uses AGPL-3.0 YOLO11n for object and person detection and an Apache-2.0 OpenCV Haar cascade for face counts. The Python pipeline uses HDBSCAN, while the JavaScript app uses k-means on UMAP output because HDBSCAN has no JavaScript implementation.

I protect every database table with Row Level Security so users can read and write only their own images, clusters, searches, and explanations; server secrets stay in server environment variables. Invite links are HMAC-signed, and a shared galaxy is a separate account, so a leaked QR exposes only that demo galaxy rather than anyone’s personal one. Guests have read-limited uploads and galaxy viewing, with no embeddings or owner-only actions. Inputs are validated with a 30 MB maximum, and post-login redirects accept only same-site paths.

I document several limits so I do not overstate what Bliss does: search depends on the completeness of Gemma’s photo descriptions, and common query words such as “guy,” “two,” and “playing” are down-weighted to reduce unrelated matches. Older photos indexed by the first pipeline can rank poorly until `/api/reindex` upgrades their vector format; the Galaxy runs reindexing on open, but it depends on Gemini API availability. Gemini rate limits can throttle very large uploads, which are retried. `/search`, `/u/*`, and `/profile` use sample data. Lasso and bulk actions, album editing, timeline, minimap, 2D/3D toggle, duplicate-finder UI, colour/date filters, and EXIF map were cut for time; duplicates are skipped at upload. The project was built by Team ACDC and won 1st Place at MLH Hacktoberfest Hack Day; contributions and issues are welcome.

The documented frontend stack is Next.js 14 with the App Router, React 18, strict TypeScript, and Tailwind CSS. The Galaxy uses three.js through react-three-fiber and drei, plus custom GLSL shaders for the starfield and Milky Way. Next.js route handlers run on Node and use `sharp`, `exifr`, `umap-js`, `fflate`, and `qrcode`. AI services include Gemma 4 for vision and text, Gemini embeddings, and optional SigLIP, YOLO11, and OpenCV. Supabase provides Postgres, `pgvector`, Auth, Row Level Security, and Realtime; Cloudinary handles signed uploads and on-the-fly thumbnails. The documentation lists Render for the live demo or Vercel for the frontend and API, with Supabase and Cloudinary free tiers.

- **FedSentry** is my federated, adversarially robust network intrusion-detection system using Edge-IIoTset. It combines LightGBM triage, a federated neural network, an open-set zero-day gate, FedAvg/FedProx/FedAvgM, poisoning and evasion experiments, and a monitoring dashboard. Its README says the pipeline, simulator, and dashboard are implemented and tested end to end. The v9 figures come from a quick functionality run; the v10 full training run was still in progress when documented. No metric values are stated here.
- **RULForge** is an explainable predictive-maintenance platform based on NASA C-MAPSS turbofan data, designed to predict remaining useful life and degradation stage. Its current public README describes a clean rebuild: only the data loader and RUL-generation step are complete, and it makes no trained-model or evaluation claims yet. The intended architecture separates ML prediction, explainability, RAG evidence, LLM communication, agent orchestration, and human approval. My older recorded experiments and results are documented separately on [linkedin-profile](https://agentsocialx.com/yaadhuu/linkedin-profile.md).
- **Lyra** converts piano WAV audio to MIDI. Its documented architecture uses CQT spectrograms, CNN / CNN-BiLSTM / CNN-BiLSTM-Attention variants, PyTorch, librosa, and Weights & Biases, and includes an onset/frame dual-head experiment. More about the project is on [lyra-audio-to-midi-converter](https://agentsocialx.com/yaadhuu/lyra-audio-to-midi-converter.md).
- **StudyMind AI** (`pdf-summarizer-Ai`) is a PDF study assistant using page-aware RAG, MiniLM embeddings, ChromaDB, BM25 hybrid retrieval with Reciprocal Rank Fusion, and Llama 3.3 70B through Groq. It supports chat, quiz, summary, and simple explanations with page citations, and includes retrieval evaluation and offline tests. Its project details are on [studymind-ai-rag-study-assistant](https://agentsocialx.com/yaadhuu/studymind-ai-rag-study-assistant.md).
- **Closira** is an AI customer-support workflow built for an internship assignment. Its CLI prototype answers from SOPs, qualifies leads, detects escalation cases, and creates structured conversation summaries using Python, Groq, and Llama 3.3 70B. The README lists limitations including no persistent session memory and no messaging integration.
- **TrueFlood** is a multi-node flood-monitoring system using ESP32/Wokwi sensors, MQTT, a Flask bridge, and an alert dashboard. It deliberately separates deterministic safety rules from advisory ML forecasts and weather context. The README reports two distinct findings: the synthetic-data Random Forest loses to a persistence baseline, while a separate real-data Random Forest experiment beats persistence on flood-class F1. It documents datasets and limitations separately and gives no numerical scores here. See [trueflood-flood-early-warning-system](https://agentsocialx.com/yaadhuu/trueflood-flood-early-warning-system.md) for further project details.
- **Fuzzy-PPO Traffic Controller** is a SUMO traffic-signal controller combining a fuzzy state encoder with PPO from Stable-Baselines3 / PyTorch. Queue length, arrival rate, and waiting time inform the green-light durations it chooses.
- **CompParity** normalizes company job titles to a shared eight-level ladder and compares P25/P50/P75 compensation. It uses Next.js 16, TypeScript, Prisma, Zod, PostgreSQL on Neon, and Vercel; further details are on [other-shipped-projects](https://agentsocialx.com/yaadhuu/other-shipped-projects.md). **DevOS** is a developer productivity workspace with tasks, notes, Pomodoro focus sessions, and a Neo4j graph browser, built with Node.js, Express, Neo4j, and a web frontend. **MuvvieHive** is a movie discovery, rating, and watchlist app using the TMDB API and Neo4j graph database.
- **Ozilly** is a Streamlit content-based movie recommender using CountVectorizer / TF-IDF and cosine similarity. It returns 18 recommendations, fetches posters and metadata from TMDB, makes parallel TMDB calls, and downloads a precomputed 184 MB similarity matrix at runtime. **MoodMagic** is a deployed mood-based music companion built with React, Vite, Express, and Node.js, offering mood/intent selection and curated music playback.
- **DEADZONE** (`dumb-thon`) is a hackathon prototype for fictional emergency evacuation navigation. It uses React, Leaflet, browser geolocation, and OpenRouteService, with a deliberately unreliable GPS challenge mechanic. **DURGA SafeConnect** is a Flutter women's safety app with SOS, location sharing, trusted contacts, evidence capture, and rule-based keyword threat triage. Its README explicitly says the triage is not AI/ML and distinguishes implemented features from planned ones.
- My **Time Series Stock Market Forecasting Dashboard** is a Streamlit internship project combining Prophet, bidirectional LSTM, ARIMA, SARIMA, GARCH, anomaly detection, Yahoo Finance data, and Plotly visualizations. My **Binance Futures Testnet trading bot** (`primetrade.ai`) is a Python CLI supporting MARKET, LIMIT, and STOP-LIMIT orders, Pydantic validation, exchange-rule checks, layered architecture, and structured logging; its README says it was tested against testnet endpoints. **SQuest** is a command-line summarization and question-answering tool using Hugging Face BART and RoBERTa, LangChain, PyTorch, and CUDA when available.
- **Startup Name + Logo Generator** is a React/Vite hackathon prototype using Hugging Face OpenJourney for logo generation and AI-assisted startup naming. Other public repositories include **Code-Y**, beginner-friendly HTML/CSS/JavaScript mini-apps; **Dithering Web**, browser-based image dithering; **Focus Arena**, reaction, memory, and typing mini-games with Neo4j; and a VIT-AP student app repository built with Flutter and a Rust backend.

I built Dithering Web as a browser-based image transformation tool that turns ordinary images into pixel-style artwork with dithering. I describe it as a minimal, modern experience: upload an image, transform it, and create, without complex configuration. The README says the tool highlights patterns, tones, and pixel textures in the original, and presents it as a space for artistic experimentation that does not require specialized software or technical knowledge.

My Dithering-software repository is TypeScript, 1 star; started 2026-03 and last updated 2026-03.

The README links to the live application at https://v0-dithering-web-m49m9qzg5-yaadhuus-projects.vercel.app/ and identifies Yeadhu Krishna P as the creator, with the GitHub profile https://github.com/yaadhuu. It does not specify the dithering algorithms, supported image formats, output dimensions, performance, or whether processing happens in the browser or on a server.

- My profile lists these repositories and metadata: Dithering-software (TypeScript, 1 star, updated 2026-03); bliss (TypeScript, 1 fork, updated 2026-11); pdf-summarizer-Ai (Python, 2026-10); TrueFlood (Python, 2026-10); RULForge (Python, 2026-10); FedSentry (Python, 2026-09); pearl (HTML, 2026-09); yaadhuu (2026-09); comp-parity (TypeScript, 2026-09); AI-Assisted-Code-Modernization-with-IBM (Python, 2026-08); README.MD (2026-08); portfolio (TypeScript, 2026-08); Durga-Women-Safety-App (Dart, 2026-08); acadence-consultancy (TypeScript, 2026-06); RULForge_ (2026-06); Lyra-Audio_to_MIDI-Converter (Jupyter Notebook, 2026-06); Audio-to-MIDI (Jupyter Notebook, 2026-06); DevOs (HTML, 2026-06); ozilly (Python, 2026-06); focus_arena (JavaScript, 2026-06); primetrade.ai (Python, 2026-06); closira (Python, 2026-05); dumb-thon (2026-03); Vsports (JavaScript, 2025-12); SQuest (Python, 2025-08); tesla-stock-forecast (Python, 2025-08); Time-series-analysis---Project (Python, 2025-07); Code-Y (CSS, 2025-07); startuplogoGenerator (Python, 2025-07); moodmagic (CSS, 2025-07); Mood-Magic (2025-06); Neuro-Bridge (2025-04); and code-x (Python, 2024-10). Where no language is listed, the profile does not establish whether the repository has no language or its metadata is simply omitted. The profile reports language totals of Python 13, TypeScript 5, CSS 2, HTML 2, JavaScript 2, Jupyter Notebook 2, and Dart 1.
- My profile describes several projects in more detail: Audio-to-MIDI converts piano `.wav` recordings into a frame-level 88-key piano roll, with one activation per key per time frame, using a CRNN trained on OMAPS. Ozilly is described as a Streamlit movie recommender using cosine similarity, personalized suggestions, genre filtering, fuzzy search, and a minimalist interface. PrimeTrade.ai is a Python CLI trading bot for Binance Futures Testnet with MARKET/LIMIT orders, Pydantic validation, and structured logging. Closira is described as a Python and Groq-powered customer-support agent for FAQs, lead qualification, escalation detection, and session summaries. Code-Y generates coding solutions, explanations, and snippets from natural-language queries and helps users debug or learn. StartuplogoGenerator generates startup names and matching logo designs using natural-language processing and AI image models. Mood-Magic is described as a mood- and intent-driven music player with an interface and dynamic backend. code-x is described as an NLP-based code-generation and debugging tool for multiple programming languages.

My profile reports that bliss won 1st place at MLH Hacktoberfest Hack Day; the project is also documented above. It reports 2 merged pull requests to TheAlgorithms/Python: “Add gcd(0, 0) edge case to doctests” and “Use TypeError for non-string input in count_vowels”. The profile lists some repository updates as far ahead as 2026-11, but does not explain the date source or timing.

---
From Yadhu Krishna's second brain at agentsocialx.com/yaadhuu