What are my actual chances of getting into IIT Bombay CS? Or NIT Trichy ECE?
This project answers that question. It takes real JoSAA closing rank data (2018–2025), your JEE rank, and your preference list — then runs 500 Monte Carlo simulations with a Gale-Shapley matching engine to estimate your probability of landing each branch.
No guesswork. No vague "you might get in." Just hard percentages.
Every year, lakhs of students stare at last year's cutoffs and wonder — "will it go up or down this year?"
Cutoffs aren't fixed. They fluctuate. A branch with CR 5000 last year might close at 4700 or 5400 this year depending on a hundred different factors. So instead of looking at a single number, this simulator models that uncertainty.
It asks: if we simulate the allocation process 500 times, each with slightly different cutoffs, how often do you get in?
That's your real chance.
┌─────────────────────────────────────────────────────────────┐
│ Your Rank + Preferences │
└──────────────────────────┬──────────────────────────────────┘
│
▼
┌────────────────────────┐
│ Load JoSAA Data │ ← merged_jee_cutoff_2018_2025.csv
│ (Pick any year, │ (434k rows, 8 years)
│ OPEN, Gender-Neutral)│
└────────────┬───────────┘
│
╔════════╧════════╗
║ × 500 rounds ║
╠═════════════════╣
║ ║
║ 1. Perturb ║ ← Real historical volatility from
║ cutoffs ║ year-over-year rank changes
║ ║
║ 2. Generate ║ ← Create fake competitors with
║ competitors ║ realistic rank distributions
║ ║
║ 3. Run Gale- ║ ← Sort everyone by merit,
║ Shapley ║ fill seats top-down
║ matching ║
║ ║
╚════════╤════════╝
│
▼
┌────────────────────────┐
│ Seat Won % per branch │ → Could you beat the competition?
│ Allocated % per branch│ → Will you actually end up here?
│ Unallocated % │ → Risk of getting nothing
└────────────────────────┘
Instead of hardcoded volatility percentages, the simulator computes actual year-over-year standard deviation of closing ranks from 8 years of data (2018–2025). This means:
- IIT Bombay CS (CR ~70): The simulator knows this barely moves, because the data proves it.
- A mid-tier NIT branch (CR ~15000): The simulator knows this swings hard, because the data shows it.
- New branches with < 3 years of data: Falls back to a tiered heuristic estimate.
| Scenario | Volatility Source |
|---|---|
| ≥ 3 years of historical data | Computed from real std. deviation of year-over-year changes |
| < 3 years (fallback) | Tiered estimate: 5% (CR<1k), 10% (1k-5k), 15% (5k-10k), 25% (10k-20k), 30% (>20k) |
- Java 24 (or any recent JDK)
- Maven
mvn compile
mvn exec:java -Dexec.mainClass="Main"Or just run Main.java from IntelliJ / Eclipse / VS Code.
JoSAA Predictive Seat Allocation Engine
Loading JoSAA dataset (this might take a few seconds)...
Loaded 879 branches from JOSAA 2025 data (Round 6).
What do you want to predict?
1. IIT admissions (uses JEE Advanced rank)
2. NIT/IIIT/Other admissions (uses JEE Main rank)
3. Both IIT + NIT
Your choice (1/2/3): 1
Enter your JEE Advanced rank: 3500
Loaded 281 branches for simulation.
Enter branch keywords to filter preferences (e.g. COMPUTER_SCIENCE, ELECTRICAL).
Separate multiple keywords with commas, or press Enter for all branches:
> COMPUTER,ELECTRICAL
Matching Branches (sorted by Closing Rank)
1. IIT_BOMBAY__COMPUTER_SCIENCE_AND_ENGINEERING [IIT] CR=66
2. IIT_MADRAS__COMPUTER_SCIENCE_AND_ENGINEERING [IIT] CR=171
...
Enter preference numbers in order (comma-separated), e.g. 1,3,5,7
Or type 'ALL' to use all 48 branches in order:
> 1,2
Your Preference List
1. Indian Institute of Technology Bombay | Computer Science and Engineering (4 Years, Bachelor of Technology) (CR=66)
2. Indian Institute of Technology Madras | Computer Science and Engineering (4 Years, Bachelor of Technology) (CR=171)
Loading...
Results:
Student: You | Main Rank: 35000 | Advanced Rank: 3500
Seat Won = Could you beat competitors for this branch?
Allocated = Will you end up here? (based on preference order)
Branch Type CR Seat Won Allocated
----------------------------------------------------------------------------------------------------
Indian Institute of Technology Bombay | Computer Science ... [Adv] CR=66 0.0% 0.0%
Indian Institute of Technology Madras | Computer Science ... [Adv] CR=171 0.0% 0.0%
----------------------------------------------------------------------------------------------------
UNALLOCATED 100.0%
Completed in 40 ms.
Two numbers matter for each branch:
-
Seat Won % — In how many of the 500 simulations your rank was good enough to grab a seat in this branch, regardless of anything else. Think of it as: "can I get in here?"
-
Allocated % — In how many simulations you'd actually end up at this branch. This factors in preference order — if you won a seat at a higher-preference branch too, you'd go there instead. Think of it as: "will I land here?"
Example interpretation:
- IIT Madras EE: 89.4% seat won, 89.4% allocated → you're almost certainly going here
- IIT Kanpur ME: 42.6% seat won, but only 4.6% allocated → you could get in, but IIT Madras absorbs you in most simulations. It's a safety option.
- UNALLOCATED 5.4% → small risk of not getting any of these branches
JoSSASimulator/
├── pom.xml
├── README.md
└── src/main/
├── java/
│ ├── Main.java # CLI — takes input, shows results
│ ├── MonteCarloSimulator.java # Runs 500 simulated rounds
│ ├── GaleShapleyEngine.java # Merit-based seat allocation
│ ├── MockStudentGenerator.java # Generates competitor pools
│ ├── JossaDataLoader.java # Parses JoSAA CSV data
│ ├── Branch.java # Institute + program model
│ ├── Student.java # Rank + preferences model
│ └── InstituteType.java # IIT or NIT enum
└── resources/
└── merged_jee_cutoff_2018_2025.csv # Real JoSAA data (2018–2025)
The simulator uses a merged dataset (merged_jee_cutoff_2018_2025.csv) containing 434,000+ rows of JoSAA opening and closing ranks across 8 years (2018–2025), all rounds. The loader automatically selects the last round of the chosen year for simulation.
The CSV contains all categories, quotas, and genders. The loader filters for:
- Seat Type: OPEN only
- Gender: Gender-Neutral only
- Quota: AI (All India) for IITs, AI or OS (Other State) for NITs
Instead of guessing how much cutoffs fluctuate, the simulator:
- Loads closing ranks for every branch across all 8 years (last round only)
- Computes the standard deviation of year-over-year percentage changes
- Uses that real volatility as the Gaussian noise parameter for each branch
- Clamps volatility between 3% and 40% to prevent outliers
- Falls back to tiered heuristics for branches with < 3 years of data
For each branch in each simulation round, the generator creates a pool of fake students:
- Pool size: 85%–125% of branch capacity (randomized)
- Ranks: Gaussian distribution centered on the closing rank, with 25% spread
- For IIT branches, a Main rank is derived from Advanced rank × (8–12) as a rough conversion
- IIT branches: 60 seats
- NIT/IIIT branches: 120 seats
These are approximations — actual seat counts vary by branch.
It's a simplified version. Since bot students don't have real preferences (they only compete for one branch at a time), it reduces to: sort everyone by rank, fill seats until full, check if you made it in. The preference-order logic happens one level up in the simulator.
- Only models OPEN category, Gender-Neutral seats — no SC/ST/OBC/EWS reservation
- Branch capacities are estimated, not exact
- Competitors are synthetic, not based on real applicant data
- Models single-round allocation, not the multi-round JoSAA process
- Program names may vary slightly across years (may cause some branches to not match historically)
For educational and personal use.