
## Overview

FLO models traffic as continuous vector fields (curb/median repulsion, goal attraction, inter-vehicle discomfort) combined with bicycle-model vehicles. Local interactions produce global structure: lanes and predictable flows without explicit lane rules.

## Key Results

- **Lane Formation Index:** 1.000 (Following) - perfect self-organization  
- **Trajectory Entropy:** 0.174 (Chaotic) - low unpredictability; structure emerges from conflict  
- **Stoppage Frequency:** 97.8% (Merging) - realistic bottleneck behavior

These metrics show: emergence works, traffic is not random, and the model reproduces realistic congestion.

## Visualization

- Real-time plots and ffmpeg-backed animations (matplotlib + FuncAnimation)
- Field visualization (quiver), vehicle trajectories, and per-frame snapshots for presentations

## Implementation Details

- Core: Python (NumPy, SciPy)
- Simulation: custom continuum field + bicycle vehicle controller
- Visualization: Matplotlib (animation to MP4)
- Experiment scripts: scenario definitions, metric logging, and plot generation

## Future Work

- Implement Fast Sweeping (O(m)) to replace FMM for linear-time field solve  
- GPU acceleration for large-scale, real-time simulations  
- Validate against real-world trajectory datasets (e.g., NGSIM)  
- Add curved roads, intersections, traffic lights, and richer driver models


p.s this is my fyp, marked in highest in the entire cs batch in FYP-1 evaluation. :3

FLO is a continuum crowds inspired traffic model that demonstrates emergent lane formation and realistic congestion negotiation as seen in chaotic traffic.

FLO - Field-based Traffic Simulator | Danish Haroon

Emergence & Continuum Methods

FLO (Field-based Traffic Model)


## Overview

**Deal Co-Pilot** is a modern SaaS application designed to streamline the investment due diligence process. By leveraging an **agentic AI architecture**, the platform automates the gathering and synthesis of market data, competitor landscapes, and company specifics to produce comprehensive investment committee (IC) memos.

## Technical Architecture

* **Agentic Orchestration**: Implemented a multi-agent system using **LangChain** and **OpenAI/Gemini**. The system utilizes specialized agents for market sizing, competitive moats, and financial sentiment analysis.
* **Real-time Web Intelligence**: Integrated **Tavily Search API** to provide agents with real-time browsing capabilities, ensuring all generated reports include verifiable citations and the latest market news.
* **Full-Stack Implementation**: Built with a **Next.js 15** frontend for a reactive user experience and a **FastAPI** backend to handle long-running asynchronous research tasks.

## Features

* **Natural Language Input**: Users simply provide a company name and website to trigger a deep-dive research cycle.
* **Dual-Model Support**: Support for both **OpenAI (GPT-4o)** for high-reasoning accuracy and **Gemini 1.5 Pro + Tavily** for cost-effective, high-volume research.
* **Live Progress Tracking**: A WebSocket-enabled dashboard allows users to monitor the research agents' thoughts and progress in real-time.
* **Professional IC Memos**: Generates formatted Markdown reports covering Market Dynamics, Competitive Landscapes, and Team Overviews.

## Technical Implementation

| Layer | Technology |
| --- | --- |
| **Frontend** | Next.js 15, Tailwind CSS, TypeScript |
| **Backend** | FastAPI, Python 3.11 |
| **AI Orchestration** | LangChain, Agentic Workflows |
| **LLMs** | OpenAI GPT-4o, Google Gemini 1.5 Pro |
| **Search Engine** | Tavily AI |
| **Environment** | Docker, Vercel |

## Key Outcomes

* **Reduced Research Time**: Automated the initial 4-6 hours of manual market research into a 2-minute agentic workflow.
* **Data Integrity**: Achieved 100% citation coverage for market claims by forcing agents to provide URL sources for every key metric.
* **Modular Design**: Created a flexible backend where new research agents (e.g., ESG Agent or Regulatory Agent) can be plugged into the pipeline with minimal configuration.

Demo : *deployment private for client
Repo : [here](https://github.com/mdanishharoon/deal-copilot)

A full-stack agentic AI platform that automates investment due diligence by orchestrating multiple research agents to generate investor-grade IC memos with real-time web citations.

Deal Co-Pilot - AI Investment Research | Danish Haroon

SaaS Application, AI Agents

Deal Co-Pilot - Agentic Due Diligence


## Overview

Worked on **IAugmentor**, a Python package for intelligent data augmentation with intraclass/interclass-aware strategies: implemented **ResNet-based embedding extraction**, **K-means clustering** for intraclass diversity analysis, and **Anchored Distribution Interpolation (ADI)** to balance datasets while preserving meaningful subgroup structure.

## Technical Implementation

- **Multi-level Augmentation Pipeline**: Designed and deployed multi-level augmentation pipeline with concurrent transformation execution (threading), cluster-aware sampling for underrepresented subgroups, and comprehensive pre/post-augmentation analysis.

- **Validation & Results**: Validated IAugmentor on **Oxford-102 Flowers** and **HAM10000** skin lesion datasets, achieving targeted class balance while maintaining intraclass diversity through intelligent cluster-based sampling, documented in automated comparison reports.

## Technologies Used

- Python
- ResNet
- K-means Clustering
- Computer Vision
- Threading/Concurrency
- Data Augmentation


A Python package for intelligent data augmentation with intraclass/interclass-aware strategies using ResNet embeddings, K-means clustering, and Anchored Distribution Interpolation.

IAugmentor - Intelligent Augmentation | Danish Haroon

AI, Computer Vision

IAugmentor - Intelligent Augmentation


## Overview

Simulating quantum circuits is computationally expensive because the state space grows exponentially with the number of qubits. This project tackles that bottleneck by representing circuits as **Tensor Networks**.

Instead of evolving a massive state vector, we treat the simulation as a **Tensor Contraction** problem. By partitioning the network and distributing the workload across multiple nodes, the simulator can handle larger circuit depths than traditional serial methods.

## The Three-Phase Pipeline

To optimize the contraction process, We implemented a structured three-phase pipeline focused on minimizing communication overhead and maximizing CPU utilization:

1. **Community Detection (Graph Partitioning)**: Using **METIS**, the simulator analyzes the tensor graph to identify "communities", groups of tensors that are tightly coupled. By partitioning the graph here, we minimize the data that needs to be swapped between MPI nodes later.
2. **Community Contraction (Hybrid Parallelism)**: Each identified community is assigned to an MPI process. Within those processes, I utilized **OpenMP** and **Julia threads** to perform the actual math (contraction) across all available CPU cores.
3. **Global Merging**: Once the local communities are reduced to single tensors, the simulator performs a final coordinated contraction to produce the end result (amplitudes).

## Technical Implementation

| Component | Technology |
| --- | --- |
| **Language** | Julia (1.8+) |
| **Distributed Computing** | MPI (via MPI.jl) |
| **Shared Memory** | OpenMP & Native Julia Threads |
| **Partitioning** | METIS |
| **Tensor Math** | TensorOperations.jl |

## Performance Insights

* **Scalability**: By moving from a serial implementation to a distributed model, we significantly reduced the memory footprint per node, allowing for the simulation of wider circuits.
* **Graph Optimization**: Implementing community detection proved vital; without it, the inter-node communication during the final merge phase created a bottleneck that negated the benefits of parallelism.
* **Thread Efficiency**: Leveraged `ThreadsX.jl` for non-blocking operations, ensuring that the CPU remained saturated during heavy matrix multiplications.

Repo : [here](https://github.com/mdanishharoon/quantum-tensor-simulator)


A high-performance quantum circuit simulation that leverages tensor network decomposition and hybrid parallelism (MPI + OpenMP) to simulate complex circuits across distributed clusters.

Quantum Tensor Network Simulator | Danish Haroon

Parallel & Distributed Computing

Quantum Circuit Simulation via Tensor Networks


## Overview

Working with deeply nested JSON in relational tools can be a headache. This project is a command-line utility designed to solve that by decomposing JSON structures into a set of normalized CSV tables. It doesn't just flatten the data; it infers a schema, assigns unique IDs, and maintains relationships through foreign keys.

## Technical Implementation

* **Compiler Toolchain**: Built using **Flex** for lexical analysis and **Bison** for context-free grammar parsing. This ensures strict adherence to JSON standards while providing precise error reporting (line/column numbers).
* **Relational Mapping**: Developed a custom algorithm to traverse the **Abstract Syntax Tree (AST)** and identify repeating patterns.
* **Objects**: Grouped into tables based on key-set similarity.
* **Nested Arrays**: Decomposed into child tables with a `<parent>_id` reference.
* **Scalar Arrays**: Converted into junction tables to handle many-to-one relationships without duplicating parent data.

## Key Features

* **Schema Inference**: Automatically detects table structures based on JSON object keys.
* **Relational Integrity**: Every row is assigned a primary key, and nested elements are automatically linked via foreign keys.
* **Robust CSV Formatting**: Handles edge cases like null values, nested quotes, and multi-line strings according to standard CSV RFCs.
* **AST Visualization**: Includes a debug mode to print the Abstract Syntax Tree, useful for verifying the parsing logic of complex files.

## Technical Stack

| Category | Tool / Library |
| --- | --- |
| **Language** | C (C99 Standard) |
| **Lexer** | Flex |
| **Parser** | Bison |
| **Data Structures** | GLib-2.0 |
| **Build System** | GNU Make |

## Repo Link

Repo : [here](https://github.com/mdanishharoon/json2csv)


A high-performance CLI tool that parses complex JSON data and flattens it into a relational database-style schema, generating multiple linked CSV files with primary and foreign key integrity.

JSON to Relational CSV Converter | Danish Haroon

Systems Programming, Compilers

JSON to Relational CSV Converter


## Overview

Built **Two-Tongue Tales**, a SaaS platform where users can generate bilingual stories with AI-created images. Developed entirely solo, handling everything from the frontend and backend to the database, AI integration, payments, and deployment. The app lets users create stories, manage a library, purchase credits, and track their content in real-time.

## Frontend & UX

Built with **Next.js 16** and **React 19**, creating a responsive interface that works across devices. Used **Radix UI** components for accessible, polished interactions and **Tailwind CSS** for styling. The app includes story creation workflows, user dashboards, a story library, and checkout flows.

## Backend & Database

Used **Drizzle ORM** with **Supabase** to manage user data, stories, and credits efficiently.

## AI & Image Generation

Integrated **Google Gemini API** to generate bilingual stories based on user input. Used **Cloudinary** to handle image generation and storage for story illustrations.

## Authentication & Payments

Implemented **NextAuth** + **Resend** + **Supabase** for secure user authentication with magiclinks. Connected **Stripe** to handle credit purchases and manage the subscription/credit system with webhook validation.

## Technologies Used

- **Frontend**: Next.js 16, React 19, TypeScript, Tailwind CSS, Radix UI
- **Backend**: Next.js API Routes
- **Database**: PostgreSQL, Drizzle ORM
- **AI**: Google Gemini API
- **Images**: Cloudinary
- **Auth**: NextAuth
- **Payments**: Stripe
- **Email**: Resend

## Key Features

- AI-generated bilingual stories
- Dynamic image generation
- Credit-based purchase system
- User authentication and profiles
- Story library and management
- Real-time story status tracking
- Mobile-friendly responsive design

Working on a full-stack SaaS platform that generates bilingual stories with AI-created images. Handles user authentication, payments, and credits. Developed entirely solo from concept to production.

Two-Tongue Tales | Danish Haroon

AI-Powered Bilingual Story Generation Platform

Two-Tongue Tales


## Overview

Engineered a full-stack journal application with **FastAPI** for a high-performance backend and **Next.js** for a responsive frontend, implementing secure authentication, CRUD operations, and RESTful API integration.

## Infrastructure & Deployment

- **Containerization**: Containerized all components with **Docker** and deployed on **Kubernetes**, using Ingress for intelligent load balancing, ConfigMaps and Secrets for environment management, and horizontal scaling for reliability.

- **CI/CD Automation**: Automated infrastructure provisioning and CI/CD pipelines using **Terraform**, **Ansible**, **GitHub Actions**, and **ArgoCD**, deploying seamlessly to **AWS EC2** for scalable, cloud-native operations and continuous delivery.

## Technologies Used

- FastAPI
- Next.js
- Docker
- Kubernetes
- Terraform
- Ansible
- GitHub Actions
- ArgoCD
- AWS EC2

Repo : [here](https://github.com/mdanishharoon/journal-app)


Engineered a full-stack journal application with FastAPI and Next.js, containerized with Docker and deployed on Kubernetes with automated CI/CD pipelines.

Journal Management Platform | Danish Haroon

Web Development, Cloud Native

Journal Management Platform


## Overview

Vrite is a modern full-stack collaborative text editor built with **Next.js**, powered by **Tiptap**, **Liveblocks**, **Convex**, and **Clerk**. Designed for real-time collaboration, authentication, and cloud persistence, Vrite enables seamless team writing and editing with live synchronization.

## Features

* **Authentication**: Secure user authentication and session management via Clerk.
* **Rich Text Editing**: Feature-rich editor experience powered by Tiptap, supporting various formatting and extensions.
* **Real-Time Collaboration**: Live cursors, multi-user editing, and presence synchronization using Liveblocks.
* **Serverless Backend**: Reactive storage and database management using Convex for low-latency data fetching.
* **Document Management**: Capabilities to create, rename, and organize multiple documents per user with instant auto-save.

## Technical Implementation

| Layer | Technology |
| --- | --- |
| **Frontend** | Next.js (App Router), Tailwind CSS, Tiptap |
| **Auth** | Clerk |
| **Real-time** | Liveblocks |
| **Backend / DB** | Convex |
| **State Sync** | Liveblocks + Convex |
| **Hosting** | Vercel (Frontend), Convex Cloud (Backend) |

## Performance & Scalability

By leveraging a serverless architecture, Vrite handles document state transitions through **Convex** mutations, ensuring that all collaborators stay in sync without manual refreshes. The integration of **Liveblocks** provides a WebSocket-based layer for ephemeral data like cursor positions, reducing the load on the primary database while maintaining a highly responsive user interface.

Demo : [here](https://vrite-docs.vercel.app)
Repo : [here](https://github.com/danishharoon/Vrite)

A modern full-stack collaborative text editor featuring real-time presence, multi-user editing, and serverless persistence using Tiptap and Liveblocks.

Vrite - Collaborative Text Editor | Danish Haroon

Full-stack Real-time Collaboration

Vrite - Collaborative Text Editor


## Overview

Dominayt is a real-time multi-player game that blends territory control with "bullet-hell" dodging mechanics. The project serves as a practical exploration of low-level network programming, requiring high-frequency state synchronization between a server and multiple clients to ensure a fair and responsive gameplay experience.

## Gameplay Mechanics

The objective is twofold:

1. **Domination**: Players must reach and stay within the center of the game grid to accumulate points.
2. **Evasion**: A central cannon fires bullets at players; getting hit resets your progress or position, forcing a balance between aggressive point-scoring and defensive movement.

## Technical Implementation

* **Socket Programming**: Implemented a custom communication protocol using Python's `socket` library. The server acts as the "source of truth," managing player coordinates, bullet trajectories, and collision logic.
* **Concurrency**: Used multi-threading on the server side to handle multiple simultaneous client connections without blocking the main game loop.
* **State Synchronization**: Developed a serialized data exchange format to broadcast the positions of all players and projectiles across the network at 60 frames per second.
* **Client-Side Rendering**: Built the visual interface using **PyGame**, transforming raw coordinate data from the server into a smooth graphical experience.

## Project Structure

| File | Responsibility |
| --- | --- |
| **`server.py`** | Coordinates game logic, handles client connections, and broadcasts state updates. |
| **`client.py`** | Renders the UI, captures user input, and communicates with the server. |
| **`my_classes.py`** | Contains OOP definitions for Players, Bullets, and Game Grids. |

## Key Challenges

One of the primary hurdles was managing **network latency**. To prevent players from "teleporting" due to lag, I implemented basic client-side interpolation and optimized the data pickles to be as lightweight as possible, ensuring that the game felt "snappy" even with multiple players on the grid.

## Repo Link

Repo : [here](https://github.com/mdanishharoon/dominayt)


A fast-paced multi-player arcade game built with Python Sockets and PyGame, where players compete for central territory while dodging dynamic obstacles in a synchronized network environment.

Dominayt - Socket-based Multi-player Game | Danish Haroon

Network Programming, Game Development

Dominayt! - Multi-Player Socket Game


## Overview

Writing a game in Assembly is a labor of love and a test of patience. **Pacman-ASM** is a project I built during Spring 2023 that reimagines the classic arcade experience at the register level. I was able to gain a deep understanding of how software interacts directly with the CPU and memory.

This project stands out as one of my most rewarding builds because it required managing every minute detail, from manual memory addressing to timing game ticks using hardware interrupts.

## Technical Implementation

* **Direct Memory Addressing**: Instead of objects and classes, every pellet, ghost, and wall was managed through direct memory offsets and data buffers.
* **Irvine32 Library**: Leveraged the Irvine32 library to handle console output, color changes, and keyboard input polling without needing to write custom BIOS interrupts for every operation.
* **Audio Integration**: Implemented sound effects (`pacman.wav`, `coin.wav`) by triggering system-level audio calls within the Assembly source, bringing the "arcade feel" to a low-level environment.
* **Collision Detection**: Managed through coordinate comparison logic within the `EAX` and `EBX` registers.
* **Movement**: Implemented using conditional jumps (`JMP`, `JE`, `JNE`) to evaluate user input and wall boundaries.

## Project Highlights

| Feature | Low-Level Mechanism |
| --- | --- |
| **Graphics** | ASCII-based rendering using direct console buffer manipulation. |
| **Input** | Real-time polling of the keyboard buffer to prevent input lag. |
| **Scoring** | Integer arithmetic performed directly in registers with memory-mapped storage. |
| **Audio** | Procedure calls to external Windows API functions through the Irvine linker. |

## Reflections

This is easily one of the "nicest" things I've made because of the sheer craftsmanship involved. There are no "shortcuts" in x86; if you want a character to move, you have to manually calculate its new memory position, clear the old one, and redraw the pixel. It turned a simple game into a complex puzzle of registers and logic gates.

## Repo Link

Repo : [here](https://github.com/mdanishharoon/pacman-asm)

A fully functional recreation of the classic Pacman arcade game written entirely in x86 Assembly language, utilizing the Irvine32 library for hardware abstraction and console control.

Projects