SelfLinux Recommender is a desktop application that helps users choose a Linux distribution based on their hardware, personal preferences, and intended use case. It scans the system, asks a set of preference questions, ranks Linux distributions with a score-based recommendation engine, downloads the latest official ISO dynamically, verifies the ISO checksum, and can help write the image to a USB drive.
In short: it tries to answer the classic question, "Which distro should I install?" without starting a 400-comment internet debate. No promises about avoiding the debate entirely :)
This version is a major redesign and feature upgrade. The interface has been rebuilt with a clean, minimal style, the recommendation system is now score based, ISO downloads are resolved dynamically from official mirrors, and downloaded images can be verified using SHA checksums before being written to USB.
The goal is simple: make the process safer, smarter, and less confusing, especially for users who are new to Linux
The application now uses a shared theme system in theme.py. The design is intentionally simple: light background, white cards, thin borders, consistent fonts, and straightforward buttons. There are no heavy animations, no glow effects, and no visual fireworks like those AI ones. Also, ur GPU can relax :D
The redesigned screens include:
- Welcome screen
- Warning screen
- Hardware overview screen
- Preferences questionnaire
- Recommendation screen
- Installer/download window
- SHA verification dialog
SelfLinux now performs a more detailed hardware scan and converts the results into a weighted 0-100 hardware score.
It probes:
- CPU model, vendor, generation, cores, threads, clock speed, and performance score
- GPU model, VRAM, and performance category
- RAM size, available memory, usage, type, speed, and slot information where available
- Storage type, size, free space, and whether it is NVMe, SSD, HDD, or eMMC
- Battery presence, percentage, and charging status
The overall hardware score is used by the recommendation engine to decide whether a distribution is a good fit for the machine.
The old fixed matrix has been replaced with a score-based engine in recommender_engine.py.
The engine considers:
- Hardware score
- CPU, GPU, RAM, and storage categories
- Primary use case
- Linux experience level
- Visual design preference
- Windows-like interface preference
- Update preference
- Gaming intensity
- Battery priority
- Privacy preference
- Free software preference
- Preferred desktop environment
It ranks distributions by match score and explains why each recommendation was chosen. This makes the result easier to understand, instead of just saying "install this because the table said so." Tables are useful, but they are not known for their emotional intelligence.
The preferences screen now asks more detailed questions so recommendations can be more personal.
Questions include:
- What is your primary use case?
- How experienced are you with Linux?
- Is visual design important?
- Do you want a Windows-like interface?
- Do you prefer stable or cutting-edge updates?
- How serious is your gaming?
- Is battery efficiency important?
- Is privacy important?
- Do you prefer a fully free-software experience?
- Do you have a preferred desktop environment?
SelfLinux no longer depends on a fixed list of hardcoded ISO filenames or old download links.
The new iso_resolver.py module can:
- Follow HTTP redirects
- Query official release directories
- Scrape mirror index pages
- Find the latest matching ISO using regex patterns
- Return the final download URL
- Return checksum URLs when available
This is useful because Linux ISO URLs often change when a new release appears. Apparently, distributions enjoy moving furniture around when nobody is looking.
Supported dynamic resolvers include:
- Ubuntu LTS
- Xubuntu
- Lubuntu
- Debian XFCE
- Linux Mint Cinnamon
- Linux Mint XFCE
- Fedora Workstation
- openSUSE Tumbleweed
- Void Linux
- KDE neon
- Pop!_OS
- Zorin OS
- elementary OS
- Nobara
- antiX
- Linux Lite
- Peppermint OS
Some distributions provide clean official checksum files, while others make the process less convenient. SelfLinux handles what it can and clearly informs the user when manual verification is recommended.
The installer window now downloads ISO files directly inside the application.
It shows:
- Download status
- Progress percentage
- Downloaded size
- Total size when available
- Download speed
- Destination path
The previous manual browser-download workflow has been replaced by automatic downloading. You may still select a local ISO manually if automatic URL resolution fails.
After downloading an ISO, SelfLinux can verify its integrity using official checksum files.
The new sha_verify.py module provides:
- SHA-256, SHA-512, SHA-1, and MD5 hash calculation support
- Chunked file hashing for large ISO files
- Progress reporting during hashing
- Checksum file downloading
- Expected hash parsing by filename
- A verification dialog showing computed and expected hashes
If the checksum matches, the user sees a success message. If it does not match, SelfLinux warns the user and disables USB writing for that ISO.
This is important. A corrupted ISO is bad. A tampered ISO is worse. A tampered ISO written to your only USB stick at 2 AM is a character-building experience nobody asked for.
SelfLinux can help write the ISO to a USB drive.
On Windows, it detects USB disks using PowerShell and attempts to write using dd if available. If dd is not available, it falls back to disk preparation logic.
On Linux, it detects removable devices using lsblk and writes using dd with sudo.
Important: writing to a USB drive destroys all data on the selected device. Always double-check the selected drive.
SelfLinux can erase data when writing an ISO to a USB drive.
Before writing:
- Never select your system disk (or u get deepfried)
- Back up important files 🤓
- Verify the ISO checksum when possible (Jokes aside, do it.)
- Do not unplug the USB drive during writing (idk if I REALLY had to add ts)
The application shows warnings, but it cannot prevent every possible user mistake. Computers are very obedient, which is convenient until you accidentally tell them to do the wrong thing.
SelfLinux is written in Python and uses Tkinter for the GUI.
Python 3.10 or newer is recommended. Python 3.11 has been tested.
Required or recommended packages:
pip install psutil pillow
psutil is used for hardware probing. Pillow is used by the recommendation screen if distro logos are available.
Some optional system tools improve hardware detection:
lspcifor GPU detectionnvidia-smifor NVIDIA GPU VRAM detectionlsblkfor removable USB detectiondmidecodefor RAM speed/type/slot detailsddfor USB writing
On Debian/Ubuntu-based systems:
sudo apt install pciutils dmidecode util-linux
SelfLinux uses:
- PowerShell
- CIM/WMI queries
- Optional
dd.exeif available
The application requests administrator privileges on Windows because USB writing requires elevated permissions.
Some probes use:
system_profilerdiskutil
USB writing support is less complete than Windows/Linux and should be tested carefully.
Clone or download the project, then install Python dependencies:
git clone <your-repository-url>
cd SelfLinux
pip install psutil pillow
If you are not using Git, place all project files in the same folder and run the application from there.
Start SelfLinux with:
python main.py
On Linux, if you want USB writing to work, run from an environment where sudo dd is available.
On Windows, the application will attempt to relaunch itself as administrator if needed.
- Launch the application.
- Read the warning screen carefully.
- Continue to the hardware overview screen.
- Review the detected hardware and hardware score.
- Answer the preference questions.
- Review the ranked recommendations.
- Select a distribution and click
Download & Install. - Let SelfLinux resolve the latest ISO URL.
- Download the ISO.
- Verify the SHA checksum when prompted.
- Select the correct USB drive.
- Confirm the USB write operation.
If this sounds like a lot of steps, that is because installing operating systems safely should involve at least a little ceremony. (Yes I suck at joking ik...)
The main entry point. It creates the Tkinter application, initializes shared state, starts hardware probes, manages screen navigation, and handles the installer window.
The installer window handles:
- ISO URL resolving
- ISO downloading
- SHA verification prompt
- USB drive detection
- USB writing
Defines the shared visual style. If you want to change colors, fonts, or button styles, start here.
Contains the scoring model and distro feature matrix. This is where recommendations are calculated.
Each distro has attributes such as:
- Minimum RAM
- Ideal RAM
- Desktop environment
- Package manager
- Gaming score
- Development score
- Beginner-friendliness
- Stability
- Cutting-edge preference
- Privacy friendliness
- Free software purity
- Battery friendliness
Finds the latest ISO URLs dynamically.
It tries to use official mirrors and release directories whenever possible. For distros that do not expose clean release metadata, it uses controlled HTML scraping and regex patterns.
Computes local file hashes and compares them against official checksum files.
It provides both backend functions and a Tkinter verification dialog.
The probe modules collect hardware details:
cpu_probe.pygpu_probe.pyram_probe.pystorage_probe.pybattery_probe.py
They are designed to be independently testable from the command line.
Example:
python cpu_probe.py
python gpu_probe.py
python ram_probe.py
python storage_probe.py
python battery_probe.py
You can check Python syntax with:
python -m py_compile *.py
You can test ISO resolving with:
python iso_resolver.py "Ubuntu LTS"
python iso_resolver.py "Debian XFCE"
python iso_resolver.py "Fedora Workstation"
You can test the recommendation engine with:
python recommender_engine.py
For GUI testing on a headless Linux machine, use Xvfb:
xvfb-run -a python main.py
(Gonna add nerdface emojis to every one cuz they sound nerdy.)
Install pciutils on Linux:
sudo apt install pciutils
For NVIDIA GPUs, make sure nvidia-smi works if you want VRAM detection.
On Linux, RAM details may require dmidecode, which often requires root permissions:
sudo dmidecode --type memory
If that is unavailable, SelfLinux still detects total and available RAM.
Some distributions change their website structure or block automated requests. If automatic resolution fails, you can still select a local ISO manually.
The resolver patterns live in iso_resolver.py. If a distro changes its release page, update the relevant resolver function.
Not all distributions expose checksum files in a consistent way. When no official checksum can be parsed automatically, SelfLinux shows the computed hash so you can compare it manually against the distribution's website. (u satisfied now?)
On Windows, make sure the app is running as administrator. (trust me alr I AM NOT A HACKER.)
On Linux, check that the USB device appears in:
lsblk
Also make sure the drive is removable and not mounted in a way that prevents writing.
The UI is intentionally built with Tkinter instead of a web framework so it can remain lightweight and easy to run. The code is modular enough that major systems can be improved independently:
- Add distro support in
iso_resolver.pyandrecommender_engine.py - Improve hardware detection in the probe modules
- Adjust visual style in
theme.py - Modify questions in
preferences_screen.py - Improve ranking logic in
recommender_engine.py
To add a new distribution:
- Add its feature profile to
DISTROSinrecommender_engine.py. - Add a resolver function in
iso_resolver.py. - Register the resolver in the
RESOLVERSdictionary. - Optionally add a logo mapping in
recommendation_screen.pyif logo support is used. - Test the resolver:
python iso_resolver.py "Your Distro Name"
- Test recommendations:
python recommender_engine.py
SelfLinux tries to improve safety by verifying ISO hashes, but it is not a replacement for user awareness.
For best security:
- Prefer official distribution mirrors
- Verify checksums
- Check GPG signatures manually when available
- Do not use unknown ISO files from random links
- Review the selected USB target before writing
Checksum verification protects against corrupted downloads and some tampering scenarios. GPG verification provides stronger authenticity guarantees, and may be added in a future version.
- Some distributions do not provide easy-to-parse checksum files.
- Some resolver functions may need updates if distro websites change.
- Windows USB writing works best when
dd.exeis available. - macOS USB writing support is not as complete as Linux/Windows.
- Hardware scoring is heuristic-based, not a full benchmark suite.
- The recommendation engine is opinionated. If it recommends something you disagree with, congratulations: you are officially ready for Linux forums.
Contributions are (OFC) welcome.
Useful contribution areas to give you ideas:
- More reliable ISO resolvers
- More distro profiles
- Better GPU model categorization
- GPG signature verification
- Improved USB writing flow
- More localization support
- Better accessibility
- Test coverage
Plz keep the design simple and practical like the current one. The goal is not to create a spaceship dashboard. The goal is to help people install Linux without accidentally formatting their /dev/nvme0n1.
SelfLinux is experimental software. It can download operating system images and write them to USB drives. This can cause data loss if used incorrectly.
Use it carefully, verify what it is doing, and always double-check the selected drive before writing.
I am not responsible for data loss, broken installations, missed deadlines. (or sudden urges to tell people "🥀 I use arch btw 🥀")