What Can I Play? - Universal Game Compatibility Checker

A universal desktop application that analyzes your computer's hardware and shows you which games you can run. Designed to work fairly across all hardware configurations - from budget laptops with integrated graphics to high-end gaming rigs.

✨ Key Features

🖥️ Universal Hardware Detection

• Adaptive System Analysis: Works on any hardware configuration
• Performance Tier Classification: Automatically categorizes your system (Minimum → Ultra High)
• Cross-Platform Compatibility: Supports Windows, Linux, and macOS
• Intelligent Scoring: CPU/GPU scoring that's fair to integrated graphics

🎮 Smart Game Compatibility

• Adaptive Compatibility Thresholds: Different standards for different hardware tiers
• 86+ Games Database: Curated game database with accurate system requirements
• Real-Time Compatibility Analysis: Shows detailed compatibility explanations
• Performance Recommendations: Suggests appropriate settings for your hardware

🎯 Inclusive Design

• No Hardware Discrimination: Budget systems see games they CAN run
• Realistic Expectations: High-end systems get appropriate challenges
• Universal Store Integration: Steam, GOG, Epic Games Store links
• YouTube Trailer Integration: Preview games before deciding

🛠️ Advanced Features

• Game Search: Find specific games and check compatibility
• Database Updates: Refresh game information with latest data
• Upgrade Suggestions: Get specific recommendations for improving performance
• Export-Ready: Build to standalone executable

📸 Screenshot

🏗️ Architecture

Core Components

• universal_system_analyzer.py - Universal hardware detection and scoring
• universal_compatibility_engine.py - Adaptive game compatibility engine
• main.py - GUI application with tkinter interface
• database_manager.py - SQLite database operations
• game_scraper.py - Web scraping for game data updates

Database

• games.db - SQLite database with 86+ games and system requirements
• Comprehensive Data: Min/recommended requirements, store URLs, trailers
• Performance Scores: Quantified CPU/GPU/RAM/Storage requirements

🚀 Quick Start

Prerequisites

• Python 3.7+
• Windows/Linux/macOS
• Internet connection (for database updates)

Installation

# Clone the repository
git clone https://github.com/Zajfan/Whatcaniplay.git
cd Whatcaniplay

# Install dependencies
pip install -r requirements.txt

# Set up environment (optional - for developers)
cp .env.example .env
# Edit .env with your API keys if you plan to update game data

# Run the application
python main.py

First Launch

1. System Analysis: The app automatically detects your hardware
2. Performance Tier: You'll be classified into a performance tier
3. Game List: See games compatible with YOUR specific system
4. Detailed Info: Click games for compatibility explanations

🎮 Performance Tiers Explained

The universal system automatically classifies hardware into performance tiers:

Tier	CPU Score	GPU Score	RAM	Suitable For
Ultra High	90+	90+	32GB+	All AAA games, VR, 4K gaming
High	70+	70+	16GB+	Most AAA games, high settings
Medium	50+	50+	8GB+	Most modern games, medium settings
Low	30+	30+	4GB+	Indie games, older AAA, esports
Minimum	20+	20+	2GB+	2D games, retro games, browser games

Each tier uses adaptive compatibility thresholds for fair game recommendations.

🔧 Building & Distribution

Development Build

# Run directly
python main.py

# Or create a virtual environment
python -m venv venv
venv\Scripts\activate  # Windows
source venv/bin/activate  # Linux/Mac
pip install -r requirements.txt
python main.py

Production Build

# Create standalone executable
pip install pyinstaller

# Windows
build.bat

# Linux/Mac  
./build.sh

# Manual build
pyinstaller --onefile --windowed --name="WhatCanIPlay" main.py

📁 Project Structure

whatcaniplay/
├── 🎮 Core Application
│   ├── main.py                           # GUI application entry point
│   ├── universal_system_analyzer.py      # Universal hardware detection  
│   ├── universal_compatibility_engine.py # Adaptive compatibility engine
│   └── system_analyzer.py                # Legacy analyzer (compatibility)
├── 🗄️ Data Management
│   ├── database_manager.py               # SQLite operations
│   ├── game_scraper.py                   # Web scraping & updates
│   └── games.db                          # Game database (86+ games)
├── 🛠️ Utilities  
│   ├── init_db.py                        # Database initialization
│   ├── migrate_db.py                     # Database migrations
│   └── populate_links.py                 # Store URL population
├── 🔨 Build & Deploy
│   ├── build.bat                         # Windows build script
│   ├── build.sh                          # Linux/Mac build script  
│   ├── WhatCanIPlay.spec                 # PyInstaller config
│   └── requirements.txt                  # Python dependencies
└── 📖 Documentation
    └── README.md                         # This file

🔬 Technical Details

Universal Hardware Detection

• Cross-Platform: Uses psutil for Windows/Linux/macOS compatibility
• Intelligent GPU Scoring: Fair treatment of integrated graphics (Intel UHD, AMD Vega)
• CPU Generation Recognition: Recognizes Intel (i3/i5/i7/i9) and AMD (Ryzen) generations
• Adaptive Baselines: Different minimum scores for different hardware eras

Adaptive Compatibility Engine

• Tier-Based Thresholds: Ultra-High systems need 90% compatibility, Minimum systems need 40%
• Weighted Scoring: GPU (40%) + CPU (30%) + RAM (20%) + Storage (10%)
• Component Flexibility: System can excel in one area to compensate for another
• Realistic Explanations: "Good - Should run well at medium settings" vs generic ratings

Game Database

• 86+ Curated Games: From lightweight indies to demanding AAA titles
• Accurate Requirements: Researched and verified system requirements
• Multiple Store Support: Steam, GOG, Epic Games integration
• Rich Metadata: Trailers, descriptions, store links

🤝 Contributing

Adding Games

1. Research accurate system requirements
2. Add to games.db using provided utility scripts
3. Include store URLs and trailer links
4. Test compatibility across different hardware tiers

Improving Detection

1. Enhance hardware databases in universal_system_analyzer.py
2. Add support for new GPU/CPU generations
3. Improve cross-platform compatibility
4. Add benchmark-based scoring

UI/UX Enhancements

1. Implement modern UI framework (consider PyQt6/PySide6)
2. Add dark/light theme support
3. Improve accessibility features
4. Add configuration options

🧪 Testing Across Hardware

The universal system has been tested and validated on:

• Budget Laptops: Intel UHD Graphics, 4GB RAM → Shows appropriate indie/retro games
• Mid-Range Desktops: GTX 1060-class, 16GB RAM → Shows most modern games
• High-End Rigs: RTX 3080+, 32GB RAM → Shows all games including demanding titles
• Older Hardware: Integrated graphics, 2GB RAM → Shows lightweight games only

No hardware configuration is excluded - everyone gets fair, actionable results!

📜 License & Credits

This project is open source and available under the MIT License.

Built with:

• Python 3.7+ (Cross-platform compatibility)
• tkinter (GUI framework)
• SQLite (Database)
• psutil (System information)
• requests/BeautifulSoup (Web scraping)
• PyInstaller (Executable building)

Special thanks to:

• Steam, GOG, Epic Games for game data

• PC Gaming Wiki community

• Open source Python ecosystem

• Support for macOS and Linux hardware detection

• Integration with Steam library for owned games analysis

• Performance benchmarking integration

• Automatic game database updates

• Cloud-based compatibility database

• Game recommendation system

License

This project is for educational purposes. Respect the terms of service of websites when scraping data.

🔒 Security

Environment Variables

• .env file contains API keys and is ignored by git
• .env.example provides a template without sensitive data
• Never commit real API keys to version control

API Keys (Optional)

API keys are only needed for developers who want to update the game database:

• YouTube API: For fetching game trailers
• RAWG API: For additional game metadata

The application works perfectly without API keys using the pre-populated database.

Contributing

Feel free to contribute by:

• Adding support for new game sources
• Improving hardware detection accuracy
• Enhancing the user interface
• Fixing bugs and issues