DEV Community: Bilal Aslam

Build a YouTube Video Downloader with Python and yt-dlp

Bilal Aslam — Thu, 10 Sep 2026 21:04:11 +0000

Ever wanted to download YouTube videos directly from your Python program?

In this project, I built a simple YouTube video search and downloader using Python. The program lets you enter a search query, choose how many results you want, and download the videos with both video and audio.

This project also helped me understand how yt-dlp, FFmpeg, Python Path, and command-line based video downloading work together.

Note: Make sure you only download content you have permission to download and follow YouTube's Terms of Service and applicable copyright laws.

What I Built

The program can:

Search YouTube using a text query
Download multiple search results
Download the best available video quality
Download audio separately when necessary
Merge video and audio using FFmpeg
Save downloaded videos to a custom folder
Automatically create the download directory
Let the user decide how many videos to download

For example:

Enter the search query: GODS AMV
Enter the number of videos to download: 2

The program searches for the first two results and downloads them.

Technologies Used

This project uses:

Python
yt-dlp
FFmpeg
pathlib

The main library doing the heavy lifting is yt-dlp.

Installing the Required Packages

First, install yt-dlp:

pip install -U yt-dlp

I initially used the youtube_search package as well, but eventually removed it because yt-dlp can perform YouTube searches by itself.

That makes the final code simpler and avoids performing the same search twice.

Installing FFmpeg

FFmpeg is important when YouTube provides video and audio as separate streams.

On Windows, you can install it using:

winget install Gyan.FFmpeg

After installation, restart your terminal and verify it:

ffmpeg -version

If the version information appears, FFmpeg is available from the command line.

Why Do We Need FFmpeg?

One thing I learned while building this project is that a YouTube video isn't always downloaded as one single file.

For higher-quality videos, YouTube can provide:

Video Stream
+
Audio Stream

For example, yt-dlp may report:

Downloading 1 format(s): 399+251

Here, one format is the video stream and the other is the audio stream.

FFmpeg combines them:

Video Stream
      +
Audio Stream
      |
      v
    FFmpeg
      |
      v
Complete MP4

Without FFmpeg, the download may fail when merging multiple formats.

The Final Python Code

Here is the complete version of the project:

from pathlib import Path
import yt_dlp


DOWNLOAD_PATH = Path(r"D:\My Downloads")


def search_and_download(search_query, max_results=1):

    print(f"\nSearching for: {search_query}...")
    print(f"Number of videos requested: {max_results}\n")

    DOWNLOAD_PATH.mkdir(parents=True, exist_ok=True)

    yt_dlp_options = {
        "format": "bestvideo+bestaudio/best",
        "outtmpl": str(
            DOWNLOAD_PATH / "%(title)s.%(ext)s"
        ),
        "noplaylist": True,
        "merge_output_format": "mp4",
    }

    try:

        with yt_dlp.YoutubeDL(yt_dlp_options) as ydl:

            print("Searching for videos...\n")

            info = ydl.extract_info(
                f"ytsearch{max_results}:{search_query}",
                download=True
            )

            entries = info.get("entries", [])

            if not entries:
                print("No videos found.")
                return

            print("\nDownload complete!")

            print(
                f"\nSuccessfully processed "
                f"{len(entries)} video(s)."
            )

            return entries

    except Exception as e:

        print(f"\nError occurred: {e}")


search_query = input(
    "Enter the search query: "
)

max_results = int(
    input(
        "Enter the number of videos to download: "
    )
)

search_and_download(
    search_query,
    max_results
)

How the Code Works

Let's break it down.

1. Importing the Libraries

from pathlib import Path
import yt_dlp

Path comes from Python's built-in pathlib module.

It makes working with file and folder paths much cleaner than manually manipulating strings.

yt_dlp is responsible for searching and downloading the videos.

2. Setting the Download Directory

DOWNLOAD_PATH = Path(r"D:\My Downloads")

This tells the program where downloaded videos should be saved.

I used a raw string:

r"D:\My Downloads"

because Windows paths contain backslashes.

3. Creating the Download Folder

Inside the function:

DOWNLOAD_PATH.mkdir(
    parents=True,
    exist_ok=True
)

This makes sure the folder exists.

exist_ok=True means Python won't throw an error if the directory already exists.

parents=True allows Python to create missing parent directories if necessary.

4. Configuring yt-dlp

The main configuration is:

yt_dlp_options = {
    "format": "bestvideo+bestaudio/best",
    "outtmpl": str(
        DOWNLOAD_PATH / "%(title)s.%(ext)s"
    ),
    "noplaylist": True,
    "merge_output_format": "mp4",
}

Let's look at each option.

`format`

"format": "bestvideo+bestaudio/best"

This tells yt-dlp to prefer:

Best video
+
Best audio

and fall back to the best combined format when necessary.

This is important because using:

"bestvideo/best"

can result in downloading a video-only stream.

5. Setting the Output Filename

"outtmpl": str(
    DOWNLOAD_PATH / "%(title)s.%(ext)s"
)

%(title)s is replaced by the video's title.

For example:

YouTube Video Title.mp4

instead of something like:

video123.mp4

6. Preventing Playlist Downloads

"noplaylist": True

This tells yt-dlp not to download an entire playlist when the URL or search result happens to belong to one.

7. Merging Into MP4

"merge_output_format": "mp4"

When separate video and audio streams are downloaded, FFmpeg can merge them into an MP4 file.

8. Searching YouTube

The most important part for multiple results is:

info = ydl.extract_info(
    f"ytsearch{max_results}:{search_query}",
    download=True
)

Suppose the user enters:

GODS AMV

and:

The resulting search expression becomes:

ytsearch2:GODS AMV

That tells yt-dlp to search for two results.

If the user enters:

it becomes:

ytsearch5:GODS AMV

and searches for five results.

The Bug I Initially Had

My first version had a logic problem.

I was using:

YoutubeSearch(
    search_query,
    max_results=max_results
)

to find multiple videos.

But later I used:

ytsearch1:GODS AMV

for the actual download.

So even if I requested:

5 videos

the download logic was effectively asking:

Give me 1 video.

The search results were also not being used for downloading.

The flow was basically:

Search for 5 videos
        |
        v
Get 5 results
        |
        v
Ignore those results
        |
        v
Search again using ytsearch1
        |
        v
Download 1 video

Not exactly the world's greatest software architecture.

The Fix

I removed the unnecessary youtube_search dependency and let yt-dlp handle both searching and downloading.

Now:

f"ytsearch{max_results}:{search_query}"

controls the number of search results.

For example:

ytsearch1:anime AMV

means one result.

ytsearch5:anime AMV

means five results.

ytsearch10:anime AMV

means ten results.

9. Getting the Search Results

After extraction:

entries = info.get("entries", [])

entries contains the videos returned by the search.

We can check whether anything was found:

if not entries:
    print("No videos found.")
    return

If results exist, we display how many were processed:

print(
    f"\nSuccessfully processed "
    f"{len(entries)} video(s)."
)

10. Handling Errors

The download operation is wrapped inside:

try:
    ...
except Exception as e:
    print(f"\nError occurred: {e}")

This prevents the entire Python program from crashing without an explanation.

Instead, the user gets an error message.

Example Run

A typical run looks like:

Enter the search query: GODS AMV
Enter the number of videos to download: 2

Searching for: GODS AMV...
Number of videos requested: 2

Searching for videos...

Then yt-dlp searches for the requested number of videos and downloads them.

The files are saved inside:

D:\My Downloads

An Important Lesson About Video and Audio

One of the most useful things I learned from this project was that "best quality" does not necessarily mean "one file."

A simplified example:

1080p Video
    +
High Quality Audio
    =
Two separate streams

The downloader needs to combine them.

That's why this configuration:

"format": "bestvideo+bestaudio/best"

works together with:

"merge_output_format": "mp4"

and FFmpeg.

Troubleshooting

FFmpeg Not Installed

If you see:

ERROR: You have requested merging of multiple formats
but ffmpeg is not installed.

Install FFmpeg:

winget install Gyan.FFmpeg

Then verify:

ffmpeg -version

Restart your terminal if necessary.

Video Has No Sound

If your downloaded file has no audio, check whether your format is:

"bestvideo"

That can select a video-only stream.

Use:

"bestvideo+bestaudio/best"

instead.

Also make sure FFmpeg is installed and accessible from PATH.

yt-dlp JavaScript Runtime Warning

You may also see a warning similar to:

WARNING: No supported JavaScript runtime could be found.

This is related to YouTube's current extraction requirements and can mean some formats may be unavailable.

If basic downloading works, you may not need to solve this immediately. However, if yt-dlp starts failing to extract certain videos or formats, check the official yt-dlp documentation for the current JavaScript runtime requirements.

What I Learned From This Project

This project looked simple at first:

Search YouTube
      ↓
Download video

But it introduced several useful concepts.

I learned about:

Python functions
Exception handling
pathlib
File paths on Windows
Third-party Python packages
Command-line tools
Video and audio streams
FFmpeg
Search result handling
Debugging logic errors
Understanding what a library is actually doing behind the scenes

Most importantly, I learned that getting code to run isn't the same as understanding why it works.

For example, my original program technically searched for multiple videos, but my download logic only downloaded one. Looking at the terminal output helped me identify the actual problem.

Possible Improvements

There are several features I could add in the future:

Choose video quality
Download audio only
Download subtitles
Show download progress
Let the user choose the output folder
Add a graphical user interface
Add URL-based downloading
Validate user input
Create a download history
Add filename sanitization
Allow users to select specific search results before downloading

A GUI version would be an interesting next step.

Project Structure

For a simple version, the project can be:

youtube-downloader/
│
├── youtube_downloader.py
│
└── README.md

The downloaded videos are stored separately:

D:\My Downloads

Final Thoughts

This was a small Python project, but it turned out to be a pretty useful learning exercise.

The biggest lesson for me was debugging.

I initially had two separate problems:

The downloaded videos had no sound.
The number of requested results was not controlling the number of downloads.

The first problem was caused by downloading a video-only stream:

bestvideo

The second was caused by accidentally using:

ytsearch1

instead of dynamically using the user's requested number:

ytsearch{max_results}

After fixing both, the workflow became much cleaner:

User Input
    |
    v
yt-dlp YouTube Search
    |
    v
Requested Number of Results
    |
    v
Video + Audio Streams
    |
    v
FFmpeg
    |
    v
Final MP4

And that's another little Python project added to the learning journey.

Disclaimer

This project is intended for educational purposes. Only download videos when you have the right or permission to do so, and respect copyright, platform rules, and the creator's rights.

If You Found This Useful

I'm currently learning Python and building small projects to understand concepts by actually using them.

If you're also learning Python, don't just copy the code.

Break it.

Change it.

Make it fail.

Then figure out why it failed.

That's where the real learning starts.

RAZE Debug Mentor

Bilal Aslam — Sat, 05 Sep 2026 05:25:07 +0000

This post is my submission for DEV Education Track: Build Apps with Google AI Studio.

What I Built

I built RAZE — Debug Mentor, an AI-powered debugging mentor designed to help developers understand why their code is failing instead of simply giving them a corrected solution.

RAZE follows a structured debugging workflow:

Problem → Execution → Observation → Questions → Root Cause → Fix → Why It Works → Engineering Takeaway

Instead of immediately generating an answer, RAZE looks at the user's code, execution result, expected vs. actual behavior, and debugging context before guiding them toward the underlying issue.

One of the problems I specifically tested was a Python shallow-copy bug involving nested dictionaries. RAZE was able to identify that copying the outer list did not create independent copies of the nested objects, explain the shared-reference behavior, and recommend copy.deepcopy() as the appropriate fix.

The original RAZE project is built with Python + FastAPI. For this challenge, I imported the project into Google AI Studio, where AI Studio recreated the application as a modern TypeScript-based web app that I could run and iterate on directly in the AI Studio environment.

Demo

Live App / AI Studio Applet:
https://ai.studio/apps/9dd65d7a-41e2-460e-906c-380c386e5ba5

The demo shows the complete debugging flow: submitting a problem, running the code, examining the observed behavior, answering mentor questions, and receiving a root-cause explanation and fix.

My Experience

The most interesting part of this challenge was seeing how quickly Google AI Studio could turn an existing project into a runnable web application.

I started with an existing Python/FastAPI version of RAZE and imported the GitHub repository into Google AI Studio. AI Studio analyzed the project and recreated the application using TypeScript, allowing me to run and interact with it directly inside the AI Studio environment.

What I liked most was that I didn't have to start the application from scratch. I could bring an existing idea and codebase into the environment and then focus on getting the experience working and refining the product.

Building RAZE also taught me an important lesson about AI-assisted development:

AI can build quickly, but the developer still has to understand, test, verify, and improve what is being built.

I used AI heavily during development, but I also tested the actual debugging behavior with real programming problems, especially bugs involving mutable default arguments and shallow copies.

That process made RAZE more than just an AI chatbot that generates code. The goal is to make it feel like a calm senior developer sitting beside you, helping you understand the bug before fixing it.

Google AI Studio made experimenting with that idea significantly faster, especially when moving from an existing project into a runnable web experience.

🧠 I Built an AI That Reads Your Personality… and Roasts You 💀

Bilal Aslam — Wed, 02 Sep 2026 02:26:58 +0000

What if an AI could read your personality and roast you at the same time?

That was the idea behind MindReader AI.

MindReader AI is a fun AI-powered personality scanner built with Python and Google Gemini. It asks you 8 behavioral questions, analyzes your answers, and generates a short, personalized personality report.

And sometimes…

"BRO… HOW DID IT KNOW THAT?"💀

🧠 What Is MindReader AI?

The concept is simple:

Answer 8 questions → AI analyzes your behavior → AI exposes you.

The questions are designed around everyday situations involving:

Decision making
Criticism
Money
Social situations
Risk taking
Relationships
Overthinking
Uncertainty

The answers are sent to Gemini, which analyzes the patterns and generates a personality report.

The report can include:

Personality type
Overthinking score
Self-awareness score
Risk-taking score
Pretending-You-Don't-Care score
AI observations
A "Caught" moment
Final verdict
Confidence score

This isn't intended to be a scientific psychological assessment.

It's an entertainment project and an experiment in making AI interaction more interesting.

🎯 Why Did I Build It?

I didn't want to build another generic AI chatbot.

There are already approximately 7 billion of those. 💀

I wanted to build something where the AI's response itself becomes the experience.

Instead of:

"You appear to be moderately introverted."

MindReader might tell you:

"You said you don't care. Your brain immediately opened 17 tabs trying to figure out what they meant."

That's much more fun.

🔥 The Roast Factor

This is probably my favorite part of the project.

I specifically designed the prompt so the AI doesn't produce a boring psychological essay.

The output is supposed to be:

Short
Funny
Sarcastic
Relatable
Personalized
Slightly brutal

One of the sections is called:

🚨 CAUGHT

This is basically the AI saying:

"Yeah... I noticed that."

For example:

🚨 CAUGHT:
You said "I don't care."

Your brain immediately started analyzing
why they said what they said.

The goal isn't to insult the user.

It's to create that moment where the result feels way too relatable.

🤖 How Does It Work?

The overall flow is:

User Answers
     ↓
Question Manager
     ↓
Gemini AI
     ↓
Personality Analysis
     ↓
Personality Report
     ↓
Saved TXT Report

The QuestionManager handles the questions and user responses.

The PersonalityAnalyzer prepares the information and sends it to Gemini.

The generated result is then passed to the report system and saved as a timestamped .txt file.

This separation keeps the application easier to understand and maintain.

🧩 Project Architecture

One of the things I wanted to practice with this project was OOP and separation of responsibilities.

The project is organized roughly like this:

MindReader-AI/
│
├── main.py
├── cli.py
├── requirements.txt
│
├── src/
│   ├── analyzer.py
│   ├── questions.py
│   ├── report.py
│   └── config.py
│
├── gui/
│   ├── app.py
│   ├── theme.py
│   ├── parser.py
│   ├── components.py
│   └── views/
│       ├── welcome_view.py
│       ├── question_view.py
│       ├── scanning_view.py
│       └── result_view.py
│
├── prompts/
│   └── personality_prompt.txt
│
└── data/
    └── reports/

The exact structure may evolve as the project grows, but the main idea remains the same:

UI should not be responsible for everything.

🎨 From CLI to GUI

MindReader originally started as a CLI application.

The terminal version uses Rich to make the experience more interactive and visually appealing.

But after getting the core system working, I wanted to turn it into something that actually looked like an AI product.

So I built a full desktop GUI using CustomTkinter.

The GUI follows this flow:

Welcome
   ↓
Answer 8 Questions
   ↓
AI Scanning
   ↓
Personality Reveal
   ↓
Saved Report

The visual identity uses:

Deep charcoal background
Electric purple accents
Cyan AI/scanner accents
Rounded cards
Subtle animations
Clean typography

The goal was:

AI scanner + psychological mystery + questionable humor.

Not:

Every element glowing like it's about to launch a spaceship. 😂

🧠 The AI Scanning Experience

One problem I wanted to avoid was the GUI freezing while waiting for the Gemini response.

Nobody wants to click a button and stare at:

Not Responding...

So the AI request runs in the background while the interface remains responsive.

During the scan, the application can display messages such as:

Reading behavioral patterns...

Connecting personality signals...

Detecting suspicious levels of overthinking...

Preparing your psychological damage...

And finally:

SCAN COMPLETE ✓

The waiting period becomes part of the experience instead of looking like the application crashed.

💻 CLI Still Works

Even after building the GUI, I didn't want to throw away the original CLI version.

MindReader now supports both experiences.

🎨 GUI

Run the GUI using the project's GUI entry point.

python main.py

💻 CLI

The CLI remains available separately.

python cli.py

This gives the project two different experiences:

GUI: A polished desktop application.

CLI: A lightweight terminal-based personality scanner.

🛠️ Tech Stack

Python

The core programming language used throughout the project.

Google Gemini API

Used for generating the AI-powered personality analysis.

CustomTkinter

Used to build the modern desktop GUI.

Rich

Used to improve the CLI experience.

python-dotenv

Used for environment-based configuration and API key management.

Object-Oriented Programming

The project uses classes to separate different responsibilities instead of putting everything inside one giant file.

Because eventually that giant file would probably start reading my personality instead. 💀

📄 Saving Personality Reports

Every completed scan can be saved as a timestamped text report.

For example:

data/reports/
└── TTT_2026-08-31_19-17-51.txt

This means the result isn't lost when the application closes.

The GUI can also provide access to the generated report.

🔐 API Key Security

The Gemini API key is not hardcoded into the source code.

The project uses environment-based configuration so sensitive credentials don't need to be committed to GitHub.

A .env file should never be pushed to the repository.

For example:

GEMINI_API_KEY=your_api_key_here

The actual API key should remain private.

⚠️ Handling API Failures

While developing the project, I also encountered Gemini 503 UNAVAILABLE responses when the model was experiencing high demand.

Instead of immediately crashing the application, the project includes retry handling for temporary API failures.

The idea is simple:

API Request
     ↓
503 Error?
   ↙     ↘
 YES      NO
 ↓         ↓
Retry    Continue

This was a good reminder that using an API isn't just about making the first request work.

You also need to think about what happens when things don't work.

🧠 What I Learned

This project taught me much more than just how to call an AI API.

1. Working With AI APIs

I learned how to structure prompts, provide user context, process generated responses, and handle API failures.

2. OOP in a Real Project

Instead of practicing classes only with tiny examples, I used OOP to structure an actual application.

3. GUI Development

Building the GUI made me think about:

User experience
Navigation
Application state
Background tasks
Loading states
Error handling
Visual feedback

4. Separation of Concerns

Keeping the AI logic separate from the UI made the project much easier to work with.

5. AI + Software Engineering

The AI may generate the personality analysis, but everything around it still needs proper engineering.

The API doesn't magically write your architecture for you.

Unfortunately. 😂

📊 Example Personality Result

A typical result can look something like:

🧠 MINDREADER AI
SCAN COMPLETE ✓

TYPE:
Professional Overthinker™

📊 BRAIN STATS

Overthinking: 97%
Self-Awareness: 91%
Risk Taking: 31%
Pretending IDC: 94%

🤖 AI SAYS:

You don't make bad decisions.
You simply spend 4 hours making them.

🚨 CAUGHT:

You say "I don't care"
after thinking about it for 3 hours.

💀 FINAL VERDICT:

Emotionally stable.
Mentally running Windows 37.

CONFIDENCE: 94%

The exact result changes depending on the user's answers.

That's the whole point.

🚀 What I Want to Improve Next

There are still several ideas I'd like to explore:

More behavioral scenarios
Additional personality dimensions
Better result visualization
Custom question packs
Historical scan comparisons
More report export formats

But I'm intentionally keeping the project focused.

I don't want MindReader to become some giant psychological platform.

The goal is still:

A fun AI experiment that makes you question your own decisions. 💀

🎥 See It In Action

I've recorded both versions of MindReader:

CLI → GUI → AI scanning → personality reveal

The GUI shows the complete user experience, while the CLI demonstrates the original terminal-based version.

The most important part?

Waiting to see what the AI is going to say about you. 😂

🔗 Try MindReader AI

The project is available on GitHub:

MindReader AI

Feel free to explore the code, try the application, or experiment with the personality prompt.

And if the AI exposes you...

That's between you and Gemini. 💀

🏁 Final Thoughts

MindReader AI started with a simple question:

Can I make an AI personality scanner that's actually fun to use?

It eventually became a project where I could combine:

Python + OOP + AI APIs + GUI Development + File Handling + Project Architecture

into one application.

It's not a scientific personality test.

It's not designed to diagnose anyone.

It's simply an experiment in making AI interaction more entertaining.

And honestly, the best part is watching someone finish the questions and wait for the result.

Because sooner or later, there's always that moment:

"Wait..."

"Why is this actually accurate?" 💀

👨‍💻 Final Question

If you tried MindReader AI, what personality type do you think it would give you?

Professional Overthinker?

Silent Strategist?

Chaotic Decision Maker?

Or something even worse? 😂

⭐ If you enjoyed the project, consider giving the repository a star on GitHub.

Python #AI #Gemini #GenerativeAI #PythonProjects #OOP #CustomTkinter #GUI #SoftwareDevelopment #AIProjects #BuildInPublic #LearningInPublic

CrediSys — Building an AI-Powered Loan Management System in Python

Bilal Aslam — Sat, 29 Aug 2026 17:57:51 +0000

CrediSys — Building an AI-Powered Loan Management System in Python

I recently completed and submitted CrediSys, an AI-powered, terminal-based Loan Management System, to the Hack The Limit hackathon on Devpost.

This project started with a simple idea:

What if I built a real software system instead of another small Python practice project?

That question eventually turned into CrediSys — a system designed around the workflow of a small lending business, from registering customers and issuing loans to tracking repayments, detecting overdue installments, and analyzing business performance.

🚀 What is CrediSys?

CrediSys is a Python-based Loan Management System that manages the complete loan lifecycle from a single terminal application.

The system includes:

Customer management
Loan plan management
Loan creation and validation
Reducing-balance EMI calculations
Automatic repayment schedules
Installment payment tracking
Overdue detection
Grace-period handling
Loan status management
Business analytics
Monthly data snapshots
AI-powered staff assistance through CrediAI

The goal wasn't to build a banking application with hundreds of features.

Instead, I wanted to build a focused system where the core workflow actually makes sense from beginning to end.

🧑‍💻 Customer Management

The first part of CrediSys is customer management.

Users can:

Register customers
Validate customer information
View customer records
Update customer information
Prevent deletion of customers with unresolved loans
Soft-delete eligible completed customers

The system is designed around the Pakistani context, including validation for Pakistani CNIC and phone-number formats.

One important design decision was using soft deletion for eligible customers instead of permanently removing their records.

This means historical information can remain available for analytics and record keeping.

💰 Loan Management

Once a customer exists, a loan can be created using predefined loan plans.

Each plan defines rules such as:

Minimum loan amount
Maximum loan amount
Interest rate
Loan duration
Interest calculation method
Grace period

When creating a loan, CrediSys validates the requested amount against the selected plan before continuing.

The system then calculates:

Monthly EMI
Total interest
Total payable amount
Number of installments
Repayment schedule

📐 Reducing-Balance EMI Calculation

One of the most challenging parts of the project was implementing the reducing-balance EMI calculation correctly.

Instead of calculating interest on the original principal throughout the entire loan, the interest is calculated based on the remaining principal.

The standard EMI formula is:

EMI = P × r × (1 + r)^n / ((1 + r)^n − 1)

Where:

P = Principal amount
r = Monthly interest rate
n = Number of monthly installments

For an annual interest rate, the monthly rate is calculated as:

monthly_rate = annual_rate / 100 / 12

I didn't want the application to simply produce an EMI number.

The loan engine also generates a complete repayment schedule so that every installment contains information about its expected payment and status.

This was an important learning experience because I had to understand the mathematics behind the calculation instead of treating it as a black box.

📅 Repayment Schedules

After creating a loan, CrediSys generates a month-by-month repayment schedule.

Each installment contains information such as:

Installment number
Due date
Amount
Payment status

The schedule allows the application to track the loan throughout its lifecycle.

This became especially useful when implementing payment recording and overdue detection.

💳 Payment Management

CrediSys allows staff to record individual installment payments.

The system includes validation to prevent things such as:

Invalid installment payments
Duplicate payments
Paying multiple installments when the workflow expects an individual installment

Payment history can also be viewed for individual loans.

This helped me understand that financial software isn't simply about storing numbers.

Every action needs rules.

⚠️ Overdue Detection & Grace Periods

Another interesting part of the project was implementing overdue detection.

An installment isn't immediately considered overdue after its due date.

CrediSys supports a configurable grace period.

The basic logic is:

Due Date
    ↓
Grace Period
    ↓
Still unpaid?
    ↓
Mark as overdue

This allows the system to distinguish between an installment that is simply past its due date and one that has actually exceeded the allowed grace period.

This was one of the areas where testing different dates and payment states became particularly important.

📊 Business Analytics

CrediSys also includes basic business analytics.

The system can track information such as:

Customer statistics
Loan statuses
Total amount lent
Total amount recovered
Outstanding amounts
Expected interest

I also implemented monthly snapshots so historical business data can be compared over time.

The idea is to eventually make this layer much more sophisticated, but for this version I focused on building a reliable foundation first.

🤖 CrediAI

One of the most exciting parts of the project is CrediAI.

CrediAI is an AI assistant integrated into CrediSys using Google's Gemini API.

It can help staff with tasks such as:

Answering questions about the system
Looking up relevant loan information
Explaining business data in plain English
Helping users navigate the application
Generating useful staff-oriented responses and reports

However, there is an important architectural decision behind CrediAI.

AI does NOT control the financial logic.

Calculations such as:

EMI
Interest
Payments
Repayment schedules
Overdue detection
Loan rules

remain controlled by the application's Python logic.

The AI acts as an intelligence and assistance layer, rather than becoming the source of truth for financial calculations.

I wanted to keep that separation clear.

🏗️ How I Built It

I built CrediSys incrementally rather than trying to implement everything at once.

The development process roughly looked like this:

Customer Management
        ↓
Loan Plans
        ↓
Loan Engine
        ↓
EMI Calculation
        ↓
Repayment Schedules
        ↓
Payment Management
        ↓
Overdue Detection
        ↓
Analytics
        ↓
CrediAI
        ↓
Main Application Integration

This approach made it easier to test each part before connecting everything together.

It also helped me understand how individual modules should communicate with each other.

🗄️ Why JSON Instead of a Database?

The current version uses JSON files for persistent storage.

I know that a relational database would be more appropriate for a larger production system.

But I deliberately chose JSON for this version.

Why?

Because I wanted to understand file-based persistence and data management before introducing additional infrastructure.

For me, this project was also a learning project.

I didn't want to hide complexity behind tools that I didn't understand yet.

The next logical step would be migrating the system to something like SQLite or another relational database.

😵 Challenges I Faced

This project came with quite a few.

1. Financial calculations

Getting reducing-balance EMI calculations and repayment schedules right required understanding the actual mathematics behind them.

2. Payment states

A payment isn't just:

paid = True

There are different states and conditions that need to be handled correctly.

3. Overdue detection

The grace-period logic required careful date handling and testing.

4. Data integrity

Deleting customers, modifying loans, and recording payments can affect historical information.

I had to think about what should and shouldn't be allowed.

5. AI integration

Connecting an external AI model was relatively easy compared with figuring out how it should interact with the existing application without taking control of the core business logic.

6. Keeping the project manageable

There were always more features I could add.

At some point I had to stop thinking:

"What else can I add?"

and start thinking:

"What does the system actually need to work properly?"

That was probably one of the most important lessons from this project.

🧠 What I Learned

CrediSys taught me much more than just Python syntax.

I learned how important it is to divide a large problem into smaller modules with clear responsibilities.

I also learned about:

Data validation
File handling
JSON persistence
Date manipulation
Financial calculations
API integration
Error handling
Software architecture
Testing real scenarios
Debugging
Git and GitHub
Designing around business rules

But probably the biggest lesson was this:

Building software is mostly about solving problems and making decisions, not just writing code.

There were many times when the code technically worked but the design didn't make sense.

I had to repeatedly test, break things, rethink the approach, and improve it.

🏆 The Biggest Thing I'm Proud Of

I'm most proud that CrediSys became a complete working workflow instead of a collection of unrelated features.

A typical flow can look like:

Register Customer
       ↓
Create Loan
       ↓
Calculate EMI
       ↓
Generate Schedule
       ↓
Record Payments
       ↓
Detect Overdue Installments
       ↓
Update Loan Status
       ↓
Analyze Business Data
       ↓
Ask CrediAI for Assistance

Everything is connected.

That was the real goal of the project.

🔮 What's Next?

CrediSys is only the first version.

Some improvements I'd like to implement in the future include:

Automated unit tests
More comprehensive financial validation
PDF loan statements
Graphical user interface
Role-based staff authentication
Migration from JSON to a relational database
More advanced analytics
Better reporting
Multi-turn conversational memory for CrediAI

I don't expect to implement all of these immediately.

The project is meant to evolve alongside my own learning.

🎥 Demo

I also created a short demo showing the main functionality of CrediSys.

Demo:
https://youtu.be/deCN5ALLtwk

🔗 Project Links

Devpost:
https://devpost.com/software/credisys-ai-powered-loan-management-system

GitHub:
https://github.com/bilal-dev-0x/CrediSys-Loan-Management-System

Final Thoughts

CrediSys started as an idea for a serious Python project and became my first hackathon submission.

It isn't a perfect production banking platform, and I don't claim that it is.

But that's not what I was trying to build.

I wanted to understand what it actually feels like to take a real-world problem, break it into smaller problems, turn those problems into software, debug the inevitable mess, and eventually ship something.

CrediSys is my first version of that journey.

And I'm looking forward to building the next one.

Python #SoftwareDevelopment #ArtificialIntelligence #Gemini #MachineLearning #Devpost #Hackathon #GitHub #ComputerScience #StudentDeveloper

Random News Headline Generator in Python 📰😂

Bilal Aslam — Thu, 18 Dec 2025 14:23:10 +0000

Have you ever wanted to create funny, political, celebrity, or animal news headlines automatically? 📰

In this post, I’ll share a simple Python project that generates random news headlines. It's beginner-friendly and a fun way to practice Python programming.

What is this project about?

The Random News Headline Generator is a Python terminal-based project that generates random headlines across four categories:

Funny News 😂
Political News 🏛️
Celebrity News 🌟
Animal News 🐾

It’s perfect for beginners who want to:

Practice Python basics
Learn random data generation
Work with lists and loops
Create small but fun projects

Features

Generates random headlines in different categories
Simple terminal interface
Easy to expand with your own categories
Can be improved with file saving, GUI, or web interface

How it works

The project uses Python lists to store headlines and the random module to pick one randomly.

Here’s a simplified example:

import random

funny_news = [
    "Man Tries to Pay With Banana, Cashier Confused",
    "Cat Becomes Mayor of Small Town"
]

political_news = [
    "Election Results Shock Everyone",
    "Politician Forgets Speech on Stage"
]

category = input("Choose category (funny/political): ").lower()

if category == "funny":
    print(random.choice(funny_news))
elif category == "political":
    print(random.choice(political_news))
else:
    print("Category not found!")

You can expand the lists and categories as much as you want. But For real fun you should check my code at Github....Link is at end of post.

How to Run the Project

Make sure you have Python 3.x installed

Download or clone the repository:

git clone https://github.com/bilal-dev-0x/random-news-headline-generator.git
cd random-news-headline-generator

Run the project:

python main.py

Follow the on-screen instructions to generate random headlines 🎉

Why this project is useful

Even though it’s a small project, it helps you:
Practice Python loops and lists
Understand random module usage
Learn how to structure a small project
Build something fun and shareable

It’s a great starting point before moving on to GUI apps or web projects.

Next Steps / Improvements

Add more categories (Sports, Tech, etc.)
Add file export to save generated headlines
Convert it into a GUI app using Tkinter
Share it as a web app using Flask or Streamlit

Final Thoughts

This Random News Headline Generator is a fun beginner project that you can finish in a few hours.

It’s a good addition to your portfolio because it shows you can:

Work with Python basics
Build small projects
Think about user interaction

Check out the GitHub repo here:
Random News Headline Generator

Connect with me on LinkedIn:
Bilal Aslam

Build Your Own Jarvis AI Assistant in Python 🚀

Bilal Aslam — Tue, 30 Sep 2025 03:33:08 +0000

# Build Your Own Jarvis AI Assistant in Python 🚀

![Python](https://img.shields.io/badge/Python-3.10%2B-3776AB?style=flat-square&logo=python&logoColor=white)

![Gemini](https://img.shields.io/badge/Google%20Gemini-API-8B5CF6?style=flat-square&logo=googlegemini&logoColor=white)

![Voice Assistant](https://img.shields.io/badge/Voice-Assistant-0EA5E9?style=flat-square)

![License](https://img.shields.io/badge/License-MIT-22C55E?style=flat-square)

> A beginner-friendly Python voice assistant that listens for the wake word **"Jarvis"**, understands voice commands, performs useful desktop and web actions, and uses **Google Gemini** for AI-powered responses.

---

## Introduction

Ever wanted to build your own AI assistant like **Jarvis from Iron Man**?

I started this project as a way to learn Python, APIs, speech recognition, automation, and AI integration by actually building something instead of only following tutorials.

The project has evolved from a simple Python voice assistant into a more capable assistant using **Google Gemini** for AI-powered responses.

Jarvis can:

- 🎤 Listen for the wake word `Jarvis`
- 🗣️ Convert speech into text
- 🤖 Generate AI responses using Google Gemini
- 🔊 Speak responses using text-to-speech
- 🌐 Open websites such as YouTube, Google, and Spotify
- 🎵 Play songs from a custom music library
- 📰 Fetch and read news headlines
- 📅 Tell the current date
- ⏰ Tell the current time
- 💬 Open WhatsApp on Windows
- ⚙️ Perform different local automation tasks

The goal is not to create a perfect commercial AI assistant.

The goal is to **learn by building**.

---

# ✨ Features

## 🎤 Wake Word Detection

Jarvis continuously listens for short audio recordings and waits until it detects:

```text
Jarvis

Once detected, it responds:

Yes Commander?

and starts listening for the actual command.

The user's title is configurable through:

USER_TITLE = "Commander"

🗣️ Speech Recognition

The microphone input is recorded using sounddevice.

The recorded audio is then converted into an AudioData object and passed to SpeechRecognition.

The basic flow is:

Microphone
    ↓
sounddevice
    ↓
AudioData
    ↓
SpeechRecognition
    ↓
Text command

This gives Jarvis the ability to understand spoken commands instead of requiring keyboard input.

🤖 Gemini AI Integration

One of the biggest changes in the newer version of Jarvis is the move to Google Gemini for AI-powered responses.

The project uses Google's modern GenAI SDK:

from google import genai

The Gemini client is initialized using the API key stored in config.json:

client = genai.Client(api_key=gemini_api_key)

The Gemini model can also be configured without changing the Python code:

{
  "GEMINI_API_KEY": "YOUR_GEMINI_API_KEY",
  "GEMINI_MODEL": "gemini-3.6-flash",
  "NEWS_API_KEY": ""
}

If Jarvis does not recognize a command as one of its built-in actions, it sends the command to Gemini.

For example:

Jarvis

Explain object oriented programming in Python

Jarvis sends the request to Gemini and then speaks the generated response.

👨‍✈️ Personalized Responses

Jarvis has a configurable user title:

USER_TITLE = "Commander"

This allows the assistant to address the user naturally.

For example:

Yes Commander?

or:

Sorry Commander, this song is not in your library.

You can change this value to:

USER_TITLE = "Sir"

or:

USER_TITLE = "Bilal"

🌐 Web Automation

Jarvis can open commonly used websites directly through Google Chrome.

Currently supported:

Open YouTube
Open Google
Open Spotify

For example:

Jarvis

Open YouTube

Jarvis opens YouTube automatically in Chrome.

The current Chrome path is configured for Windows:

chrome_path = "C:/Program Files/Google/Chrome/Application/chrome.exe %s"

If Chrome is installed somewhere else on your system, this path may need to be changed.

🎵 Music Library

Jarvis can play songs from a custom music library.

Songs are stored separately in:

music_library.py

The command format is:

Play <song name>

For example:

Jarvis

Play Never Gonna Give You Up

Jarvis checks whether the requested song exists in:

music_library.library

If the song exists, Jarvis opens the saved link.

If it doesn't exist, Jarvis responds:

Sorry Commander, this song is not in your library.

This makes it easy to customize the assistant with your own songs.

📰 News Headlines

Jarvis can fetch the latest headlines using the News API.

Command:

Global news

When a valid NEWS_API_KEY is configured, Jarvis requests the top headlines and reads up to five of them.

The current implementation uses the Pakistan news endpoint:

https://newsapi.org/v2/top-headlines?country=pk

Example:

Headline 1: ...
Headline 2: ...
Headline 3: ...

The News API key is optional.

If you don't configure it, Jarvis can still be used for its other features.

💬 WhatsApp Automation

The Windows version can launch the installed WhatsApp application using PowerShell.

Command:

Open WhatsApp

Jarvis uses Windows' application launcher to find and start the WhatsApp application.

This feature is currently designed for Windows.

📅 Date and Time

Jarvis can provide basic date and time information.

Current Date

Command:

Today date

Example response:

Today is Friday, 21 August 2026

The date is generated dynamically using Python's datetime module.

Current Time

Command:

Current time

Jarvis reads the current time aloud.

It also handles the special case where the minute is exactly 00, responding with an "o'clock" style response.

🧠 AI Fallback

This is one of the most useful parts of the project.

Jarvis first checks whether a command matches one of its built-in commands.

For example:

Open YouTube

is handled locally.

But if the command doesn't match a predefined action:

Explain recursion in Python

Jarvis sends it to Gemini.

The simplified architecture looks like this:

                 ┌──────────────────┐
                 │  Voice Command   │
                 └────────┬─────────┘
                          ↓
                 ┌──────────────────┐
                 │ Speech-to-Text   │
                 └────────┬─────────┘
                          ↓
                 ┌──────────────────┐
                 │  Wake Word Check │
                 └────────┬─────────┘
                          ↓
                 ┌──────────────────┐
                 │  Command Router  │
                 └───────┬───┬──────┘
                         │   │
              Known      │   │      Unknown
              command    │   │      command
                         ↓   ↓
                  ┌──────┐  ┌─────────────┐
                  │Local │  │ Gemini AI   │
                  │Action│  │ Response    │
                  └───┬──┘  └──────┬──────┘
                      │             │
                      └──────┬──────┘
                             ↓
                    ┌────────────────┐
                    │ Text-to-Speech │
                    └────────────────┘

This gives Jarvis two different capabilities:

Deterministic local commands
AI-powered responses

🛠️ Tech Stack

Technology	Purpose
Python	Main programming language
Google Gemini	AI-powered responses
`google-genai`	Gemini API integration
`SpeechRecognition`	Speech-to-text recognition
`sounddevice`	Microphone recording
`gTTS`	Text-to-speech generation
`pygame-ce`	Audio playback
`requests`	News API requests
`webbrowser`	Opening websites
`subprocess`	Windows application automation
`datetime`	Date and time
JSON	Configuration and API keys

📁 Project Structure

The project currently follows a simple structure:

Jarvis-AI-Virtual-Assistant/
│
├── main.py
├── music_library.py
├── config.json.example
├── requirements.txt
├── .gitignore
├── LICENSE
└── README.md

The main application logic lives inside:

main.py

The music collection is managed separately in:

music_library.py

The example configuration is stored in:

config.json.example

Your real config.json should remain local and should never be uploaded to GitHub.

🚀 Getting Started

1. Prerequisites

Before starting, make sure you have:

Python 3.10 or newer
A working microphone
Internet connection
Google Gemini API key
Windows if you want to use the WhatsApp launcher

2. Clone the Repository

Clone the project from GitHub:

git clone https://github.com/bilal-dev-0x/Jarvis-AI-Virtual-Assistant.git

Then enter the project directory:

cd Jarvis-AI-Virtual-Assistant

3. Create a Virtual Environment

Create a virtual environment:

python -m venv .venv

Windows PowerShell

.\.venv\Scripts\Activate.ps1

Linux/macOS

source .venv/bin/activate

📦 4. Install Dependencies

Install the required Python packages:

pip install -r requirements.txt

This installs the libraries required for:

Voice input
Speech recognition
Gemini
Text-to-speech
Audio playback
News API requests

🔐 5. Configure API Keys

The project uses a local config.json file for API configuration.

First create it from the example file.

Windows

copy config.json.example config.json

Linux/macOS

cp config.json.example config.json

Then open:

config.json

and add your API keys.

Example:

{
  "GEMINI_API_KEY": "YOUR_GEMINI_API_KEY",
  "GEMINI_MODEL": "gemini-3.6-flash",
  "NEWS_API_KEY": ""
}

Gemini API Key

The Gemini API key is required because Gemini is used for AI fallback responses.

News API Key

The News API key is optional.

It is only required for:

Global news

⚠️ Never upload your real API keys to GitHub.

▶️ 6. Run Jarvis

Start the assistant with:

python main.py

Jarvis will initialize and begin listening.

Say:

Jarvis

Then give it a command.

🎯 Example Commands

Here are some commands you can try:

Voice Command	Action
`Hello`	Greets the user
`Open YouTube`	Opens YouTube
`Open Google`	Opens Google
`Open Spotify`	Opens Spotify
`Play <song>`	Plays a song from the music library
`Global news`	Reads up to five top Pakistan headlines
`Today date`	Tells the current date
`Current time`	Tells the current time
`Open WhatsApp`	Opens WhatsApp on Windows
Any other question	Sends the request to Gemini

For example:

Jarvis

Explain Python functions

or:

Jarvis

What is machine learning?

Jarvis can pass those requests to Gemini and speak the response.

⚙️ How The Code Works

The project is divided into several simple pieces.

1. Recording Audio

The assistant records microphone input using sounddevice.

A simplified version looks like:

recording = sd.rec(
    int(seconds * sample_rate),
    samplerate=sample_rate,
    channels=1,
    dtype="int16"
)

sd.wait()

The recording is then converted into AudioData:

audio_data = sr.AudioData(
    recording.tobytes(),
    sample_rate,
    2
)

This allows SpeechRecognition to process the recorded audio.

2. Converting Speech to Text

The recorded audio is sent to Google's speech recognition service:

command = recognizer.recognize_google(audio)

This gives Jarvis a text representation of what the user said.

3. Detecting the Wake Word

Jarvis checks whether the recognized text contains:

if "jarvis" in command.lower():

If it does, Jarvis enters command mode.

It then responds:

Yes Commander?

and records another audio clip for the actual command.

4. Processing Commands

After the wake word is detected, Jarvis checks several predefined commands.

For example:

elif "open youtube" in text.lower():
    webpath.open("https://www.youtube.com/")

This connects a spoken command directly to a Python automation task.

Other commands follow the same basic structure.

5. Sending Unknown Commands to Gemini

If none of the predefined commands match, Jarvis sends the command to Gemini.

The project creates a Gemini chat using the configured model:

chat = client.chats.create(model=gemini_model)

A prompt is then created:

prompt = f"""
You are Jarvis, a helpful AI virtual assistant.
Give short responses.
Address the user naturally as '{USER_TITLE}'.

User command: {command}
"""

The command is sent to Gemini:

response = chat.send_message(prompt)

If Gemini returns text, Jarvis speaks the response.

6. Text-to-Speech

Jarvis uses gTTS to generate speech:

tts = gTTS(text=text, lang="en")

The generated audio is saved temporarily:

tts.save(filename)

Then pygame plays the generated MP3.

After playback finishes, the temporary file is removed.

The file used for temporary speech output is:

jarvis_voice.mp3

🧩 Customization

One of the best things about this project is that you can modify it yourself.

Change Jarvis' Title

In main.py:

USER_TITLE = "Commander"

You can change it to:

USER_TITLE = "Sir"

or:

USER_TITLE = "Bilal"

Add More Songs

Open:

music_library.py

and add your own songs and links.

This allows you to create your own personalized music library.

Change the Gemini Model

The Gemini model is controlled through:

config.json

For example:

{
  "GEMINI_API_KEY": "YOUR_API_KEY",
  "GEMINI_MODEL": "gemini-3.6-flash",
  "NEWS_API_KEY": ""
}

This means you can change the configured model without directly editing the Gemini code in main.py.

Add New Commands

You can extend the command section in main.py.

For example:

elif "open github" in text.lower():
    webpath.open("https://github.com/")

Now Jarvis can understand:

Jarvis

Open GitHub

and automatically open GitHub.

🔒 Security

The project uses a local configuration file:

config.json

Your real API keys should remain there.

The repository contains:

config.json.example

instead of your actual secrets.

Make sure .gitignore excludes:

config.json
.venv/
__pycache__/
*.pyc
jarvis_voice.mp3

Never publish API keys in your source code.

🖥️ Platform Notes

The current project is primarily designed around a Windows environment.

Some functionality is platform-specific.

For example:

Google Chrome path is configured for Windows.
WhatsApp launching uses PowerShell.
Some desktop automation may need modification on Linux/macOS.
Microphone recording requires a working input device.
Speech recognition requires internet access.
Gemini responses require a valid Gemini API key.
News fetching requires a News API key.

The core Python concepts can still be adapted for other platforms.

🧠 What I Learned From This Project

This project has been a practical way for me to learn several concepts that are difficult to understand when studying them separately.

While building Jarvis, I practiced:

Python functions
Loops and conditionals
Error handling
Working with external libraries
APIs
JSON configuration
Speech recognition
Text-to-speech
Audio processing
Web automation
Windows automation
AI API integration
Modular Python projects
Git and GitHub

More importantly, I learned that a project doesn't have to be perfect before you start building it.

You can start small and keep improving it.

📈 From a Simple Python Project to an AI Assistant

The original idea behind this project was relatively simple:

Listen → Recognize → Execute

As I learned more Python and started working with APIs, the project gradually became:

Listen
   ↓
Speech Recognition
   ↓
Wake Word Detection
   ↓
Command Processing
   ↓
Local Automation OR Gemini AI
   ↓
Text-to-Speech
   ↓
Spoken Response

This progression is probably the most valuable part of the project for me.

It shows how a small beginner project can become a playground for learning new technologies.

🚧 Current Limitations

Jarvis is still a learning project, so there are several things I want to improve.

Some current limitations include:

Wake-word detection is based on speech recognition rather than a dedicated wake-word engine.
Some commands are hard-coded.
Browser paths are currently Windows-specific.
WhatsApp automation is Windows-specific.
Internet connectivity is required for speech recognition and Gemini responses.
The command router can be improved.
There are currently no automated tests.
The project does not yet have a graphical interface.
Pakistani news has a placeholder response in the current release.

These limitations are part of the reason I continue improving the project.

🔮 Future Improvements

There are several improvements I would like to make in future versions:

🧠 Better command routing
🎙️ Dedicated offline wake-word detection
📴 More offline commands
🖥️ GUI interface
🛠️ Better error handling
🧪 Automated testing
🌍 Cross-platform support
⚡ Faster voice interaction
🗂️ Better project architecture
🔌 More automation integrations
🤖 More advanced AI capabilities

The project is still evolving, so more features will likely be added as I continue learning.

📂 GitHub Repository

The complete source code is available on GitHub:

👉 Jarvis AI Virtual Assistant

Feel free to explore the code, fork the project, experiment with it, and build your own version.

💡 Final Thoughts

This project started as a way to practice Python.

It eventually became something much more interesting: a small personal AI assistant that combines voice recognition, automation, APIs, text-to-speech, and Gemini AI.

If you're learning Python, I highly recommend building projects like this.

You don't need to understand everything before starting.

Build something.

Break it.

Fix it.

Add another feature.

Break it again. 😂

That's how you learn.

I'm still improving Jarvis as I continue my journey through Python, AI, and Machine Learning.

Connect With Me

👨‍💻 GitHub:
https://github.com/bilal-dev-0x

💼 LinkedIn:
https://www.linkedin.com/in/bilal-aslam-04a456383/

📝 DEV.to:
https://dev.to/bilal-dev-0x

Thanks for reading! 🚀

If you build your own version of Jarvis, I'd love to see what you add to it.

python #ai #gemini #automation #voiceassistant #beginners #programming #pythonprojects #learninginpublic #opensource

📚 AI Study Buddy – Your Smart Text Summarizer (Heroku Back to School AI Challenge)

Bilal Aslam — Sat, 27 Sep 2025 09:41:37 +0000

What I built
I built AI Study Buddy, a web app that helps students summarize long texts into clear, short versions. It’s designed for anyone who needs quick understanding of study material without wasting time.

The app supports multiple summarization algorithms (LexRank, LSA, Luhn, Edmundson), giving flexibility to students and educators who want different styles of summaries.

It’s deployed on Heroku, making it free and accessible anywhere.

Demo
👉 Live App: https://ai-study-buddy-challenge-10c223d9b0e6.herokuapp.com/

Screenshots:

Category Submission:

Student Success (helps students save time, learn faster, and study smarter).

How I built it

Backend: Flask(Python)

Summarization: sumy library with multiple algorithms

Frontend: HTML, CSS, animations

Deployment: Heroku (using gunicorn, requirements.txt, Procfile)

I used Flask to connect the summarization logic with a clean web interface. Students paste their text, choose summarizer type, and get results instantly.

Challenges I ran into

Setting up Heroku deployment (requirements.txt, Procfile, dynos).
Debugging package versions and making sure the app runs the same on Heroku as on my PC.
Styling the app to make it both useful and enjoyable with animations.

Accomplishments that I’m proud of

Got the app running live on Heroku 🚀
Combined multiple summarization algorithms in one place.
Built a clean, animated UI that feels smooth and modern.

What I learned

How to deploy Python/Flask apps on Heroku.
The importance of package management (requirements.txt).
How different summarization algorithms work.
What’s next for AI Study Buddy
Adding support for uploading PDFs and summarizing automatically.
Integrating AI-powered summaries (transformer-based like BERT or GPT).
Expanding to multiple languages for international students.

Built with

- Python
- Flask
- Sumy
- HTML
- CSS
- Heroku

🚀 Submission for: Heroku Back to School AI Challenge

The Classic Number Guessing Game 🔢: A Perfect Python Starter Project 🎯

Bilal Aslam — Fri, 26 Sep 2025 08:07:40 +0000

🎯 Project Goal: Learn Python Basics, Loops, and File I/O

The number guessing game is a rite of passage for every new programmer. It touches on fundamental concepts like variable assignment, conditional logic ($\\text{if}/\\text{elif}/\\text{else}$), loops ($\\text{while}$), and (in this advanced version) file handling to save a high score.

This post will break down the core logic of a Python script for a simple number guessing game that challenges the player to guess a random number between 1 and 100 in the fewest attempts possible.

➡️ You can find the complete, runnable code, including setup instructions for the $\\text{Hi-score.txt}$ file, in the accompanying:
https://github.com/bilal-dev-0x/Number-guessing-game.git

💡 Code Breakdown: Key Concepts

Let's explore the essential pieces of the game's logic.

1. Game Setup: Randomness and Initialization

The game begins by selecting a random integer and setting up our counter.

import random
n = random.randint(1, 100)
guesses = 0

import random: We use this statement to bring in Python's built-in $\\text{random}$ library.
random.randint(1, 100): This line selects the secret number ($\\text{n}$) between 1 and 100, inclusive.
guesses = 0: We initialize our attempt counter. This variable will be the final metric for the player's performance and the number we save to the high score file.

2. The Core Logic: The Infinite Loop

The game loop is the heart of the application. We use a $\\text{while True}$ *loop, which runs indefinitely until a * $\\text{break}$ statement is explicitly encountered.

while True:
    guesses += 1
    a = int(input("Guess the number : "))

    if a == n:
        # Success and game over!
        print(f"You guessed correct number in {guesses} attempts.")
        break 

    elif a < n:
        # Clue for the player
        print("Higher number....Please.")

    else:
        # The other clue
        print("Lower number....Please.")

while True:: Creates the infinite game loop.
guesses += 1: Increments the counter with every single guess.
$\\text{if}/\\text{elif}/\\text{else}$ : This is the conditional logic that provides the critical feedback loop. If the guess ($\\text{a}$) is correct, we print the result and use break to exit the loop. Otherwise, the player gets a hint to go $\\text{Higher}$ or $\\text{Lower}$ .

3. Performance Review: Conditional Messaging

After the player wins and breaks out of the main loop, we evaluate their score based on a few simple tiers. This is another great use of $\\text{if}/\\text{elif}/\\text{else}$ to provide personalized feedback.

if guesses <= 10:
    print("You have done it in some attempts....this is incredible.")

elif 10 < guesses < 20:
    print("You are doing good....improve it more.")

else:
    print("Too much attempts .... try to lower the attempts count.")

4. High Score Management: Reading and Writing to a File

This is the most powerful feature of this script, introducing File I/O. It allows the program to remember the best score even after it's closed and re-opened.

# ... first, read the old high score ...
with open("Hi-score.txt","r") as f:
    content = f.read()

# ... then compare and potentially overwrite ...
if int(content) > guesses:
    with open("Hi-score.txt", "w") as f:
        f.write(str(guesses))
        print(f"High score is {guesses}")

Reading ($\\text{"r"}$ mode): We open the $\\text{Hi-score.txt}$ file in read mode to fetch the existing record. The $\\text{with open(...) as f:}$ structure is best practice as it ensures the file is always closed automatically.
Comparison: if int(content) > guesses: is the core logic. Since lower is better in this game, we check if the old score ($\\text{content}$) is a higher number (worse score) than our current score ($\\text{guesses}$).
Writing ($\\text{"w"}$ mode): If we beat the record, we open the file in write mode ($\\text{"w"}$), which overwrites the old contents with our new, lower score. We must convert the integer $\\text{guesses}$ back to a string using str(guesses) before writing it to the text file.

This simple game covers core programming pillars and offers a great foundation for building more _complex projects_!

Go ahead and fork the repository, run the code, and try to break your own_ high score_!

➡️ Find the full Python script and setup instructions here: [https://github.com/bilal-dev-0x/Number-guessing-game.git]

Python Snake-water-gun Game....!

Bilal Aslam — Thu, 25 Sep 2025 20:27:12 +0000

🐍💧🔫 Building a Snake Water Gun Game in Python — My First Console Game!

🎮 What Is Snake Water Gun?
You’ve heard of Rock Paper Scissors — now meet its quirky cousin: Snake Water Gun! It’s a fun little game where:

🐍 Snake drinks water
💧 Water drowns gun
🔫 Gun shoots snake

Each player picks one of the three, and the winner is decided based on these rules.

🧠 How I Built It in Python
I wanted to create something simple, interactive, and beginner-friendly. Here's the core logic:

📦 Step 1: Setup Choices

computer = random.choice([1, 0, -1])
youstr = input("Enter your choice : ")
youdict = {"s" : 1, "w" : -1, "g" : 0}
reversedict = {1 :"snake", 0 : "gun", -1 :"water"}
you = youdict[youstr]

The computer randomly picks a move.
The player enters s, w, or g.
I use dictionaries to map choices to numbers and back.

⚔️ Step 2: Decide the Winner

if computer == -1 and you == 1:
    print("Snake drinks water 🐍💧")
    print("You win....!")

I wrote clear if-elif conditions for every possible matchup.
Emojis make the output more fun and readable!

🚀 How to Play

Clone the repo:

bash
git clone https://github.com/bilal-dev-0x/Snake-water-gun-Game.git

Run the game:

bash
python snake_water_gun.py

Enter your move: s for snake, w for water, g for gun.

💡 What I Learned

How to use random.choice() for unpredictability.
Mapping inputs with dictionaries for clean code.
Writing readable and fun console output.

🔗 Try It Yourself!
Check out the full code on GitHub:
https://github.com/bilal-dev-0x/Snake-water-gun-Game.git