Architected and deployed a native, high-performance macOS background utility application in Swift, SwiftUI, and AppKit that transforms the physical MacBook screen notch into a responsive, real-time "Dynamic Island" tracking interface. Built the project from the ground up utilizing structured asynchronous network frameworks and robust local data layers.

Key Architectural Engineering Milestones:

• Live Data Ingestion Pipeline: Engineered a robust multi-threaded background polling framework utilizing Combine/async-await tasks to ingest, parse, and synchronize live public server streams across 8 distinct sports leagues (including full IPL, Cricket, and NFL coverage) on rapid 15/30-second cycles.
• Dynamic Geometry Adaptability: Formulated a reactive layout-inspection engine that continuously audits device screen safe-area vectors (NSScreen.main?.safeAreaInsets). Dynamically scales the graphics pipeline from an ultra-compact 220pt notched capsule to an untruncated 340pt flat-bezel pill on Intel hardware to completely eliminate horizontal text truncation.
• State Arbitration & Caching: Designed a custom rolling recency and fall-back algorithm (autoSelectActiveMatch()) coupled with a localized in-memory cache to maintain continuous UI stability during transient network dips, seamlessly pivoting the notch display between live events, completed match timelines, and upcoming fixtures.

An intelligent system that autonomously discovers, filters, and analyzes AI/ML papers from top-tier conferences (NeurIPS, ICML, CVPR, ACL, etc.). Uses Groq API for real-time LLM-powered analysis, generating technical summaries and identifying research bottlenecks. Deployed on Render with daily auto-updates and a responsive dashboard. Built with Python, FastAPI, Docker, and HTML/CSS.

Built a custom memory allocator (my_malloc / my_free) that manages a contiguous heap using Buddy Allocation and Slab Allocation, mimicking malloc/free behavior in C.

Implemented a buddy allocator with power-of-two block splitting, address-sorted free lists, and recursive buddy coalescing to reduce external fragmentation.

Designed a slab allocator that uses a Slab Descriptor Table and fixed-size object slabs, backed by the buddy allocator, including per-object and per-slab headers for efficient reuse and fast allocations.

Implemented a custom CPU thread scheduler in C using the pthreads library, supporting three core scheduling policies — First Come First Serve (FCFS), Shortest Remaining Time First (SRTF), and Multi-Level Feedback Queue (MLFQ) — along with counting semaphore synchronization. Designed to simulate real CPU and I/O device interaction on a single-core system, the project produced precise Gantt chart visualizations of thread execution.

Key features:

• Built synchronization with mutexes and condition variables to ensure thread-safe scheduling decisions.
• Implemented preemptive and non-preemptive scheduling behavior per policy.
• Added semaphore wait (P) and signal (V) logic to handle blocking and unblocking of threads.
• Managed concurrent CPU and I/O operations with a deterministic, reproducible timeline.

Built a fully automated WhatsApp bot using n8n, RapidAPI, and CallMeBot that delivers a random Bhagavad Gita verse every day at 9 AM.

• Integrated with Bhagavad Gita API (RapidAPI) to fetch verse translations.
• Used JavaScript logic to randomly select a chapter + verse.
• Encoded and sent messages through CallMeBot's WhatsApp API.
• Scheduled daily automation using n8n's Schedule Trigger.
• Demonstrated no-code/low-code automation and API integration.

Developed a deep learning–based forecasting tool using LSTM to predict next-day stock prices for major tickers (AAPL, NVDA, AMZN, etc.) based on the past 90 days of trading data.

Implemented custom LSTM architecture using PyTorch to capture time series trends. Included real-time error correction by adjusting predictions using the last known forecast deviation. Integrated PostgreSQL to log actual vs predicted prices with auto-skipped duplicates. Streamlit dashboard with dynamic charts and a real-time earnings calendar via finance_calendars.

Built an interactive Streamlit frontend for chatting with the Zephyr LLM via Hugging Face inference.

• Engineered multi-layer defenses against prompt injection.
• Regex-based guardrails that block known "ignore instructions" attacks.
• Optional Hugging Face Moderation API integration to flag & drop unsafe inputs.
• Enforced a system-level instruction header so user prompts can't override core rules.
• Persisted every user prompt, model response, and block flag in PostgreSQL for real-time auditing and analytics.
• Showcased practical expertise in AI safety, secure LLM deployment, and threat mitigation.

Fine-tuned T5-small and BART to generate research methodologies.

Tuned hyperparameters using the Optuna library to maximise ROUGE-L and BERT score performance. Conducted semantic evaluation and model comparison to measure faithfulness and coherence.

Collaborated with 9 undergraduate researchers through OSSIG to develop a multi-modal forecasting system for NASDAQ time series data using time-series RNNs and foundation models (e.g., LLaMA 3.0, DeepSeek R3).

• Compared Echo State Networks vs. LSTMs, achieving a 37% reduction in compute time.
• Processed 1,500+ textual and numerical financial reports using Scrapy & BeautifulSoup.
• Integrated sentiment analysis with candlestick data, reducing RMSE by 18%.

Developed a comprehensive, database-driven Course Scheduling Application for a college, featuring both Admin and Student functionalities with a user-friendly GUI. Implemented full CRUD operations and advanced scheduling logic with proper use of object-oriented design principles and PreparedStatements for database integrity and security.

Key Features — Admin Functions:

• Add and manage semesters, courses, classes, and students.
• Display student lists by class (scheduled and waitlisted).
• Drop students or classes with automatic waitlist updates.

Student Functions:

• Schedule classes with automatic waitlist management.
• View and manage class schedules for the current semester.
• Drop classes with dynamic rescheduling for waitlisted students.

Design Highlights:

• Built a modular architecture with over four core Java classes representing database entities and access logic.
• Developed a Derby relational database with strong correlation to object-oriented design.
• Implemented robust GUI components using JComboBoxes and JTables for intuitive user interaction.
• Ensured database updates used SQL PreparedStatements to prevent SQL injection and maintain code clarity.

Built an interactive drawing application in Java that lets users create and customize geometric shapes (lines, rectangles, and ovals) with features like color gradients, stroke styles, and real-time mouse tracking.

Key Features:

• Implemented a combo box–based shape selector and gradient color chooser using JColorChooser and GradientPaint.
• Added Undo and Clear Canvas functionality using an ArrayList<MyShapes> to manage drawing history.
• Integrated JCheckBoxes and JSpinners to toggle filled/unfilled shapes, dashed lines, and adjust stroke width or dash length dynamically.
• Used event listeners to handle drag-and-draw operations and display mouse coordinates in a live status bar.
• Followed an object-oriented design with a custom MyShapes hierarchy (MyLine, MyOval, MyRectangle) to encapsulate drawing logic.