Welcome to My Portfolio
I'm Abdullah Alzahrani, a passionate self-taught developer. This portfolio serves as a living document of my learning journey, showcasing the projects I've built while learning foundational programming concepts and developing my skills toward becoming a back-end and eventually full-stack developer.
Tools & Technologies
C# Desktop Projects
A collection of desktop applications built with C# and the .NET Framework.
Tic-Tac-Toe Game
A simple desktop Tic-Tac-Toe game built with C# and Windows Forms, featuring two-player gameplay and round tracking.
To-Do List App
A desktop to-do list application to manage tasks, built with C# and Windows Forms, featuring task persistence.
Ajr
A C# desktop application that displays notifications containing Islamic Doua (prayers) at user-defined intervals. Built with Windows Forms.
C++ Console Projects
Projects are listed from newest (at top) to oldest (at bottom). Content is subject to updates.
Bank Management System
A structured OOP-based banking system that manages clients, users, transactions, and currencies with file-based storage and secure user authentication
Queue Line Management System
A console-based system that manages client queues, tickets, and services efficiently
Bank & ATM Management System
A complete banking and ATM simulation system built using structured procedural programming
Library Management System
A simple app to manage books by adding, borrowing, returning, and removing with live updates
Math Quiz Game
A logic-based quiz that generates random math questions by difficulty and operation type
Rock Paper Scissors Game
A fast-paced console game with random moves, score tracking, and multiple rounds
Utility Classes & Libraries
Projects are listed from newest (at top) to oldest (at bottom). Content is subject to updates.
Doubly Linked List Class
A template-based class for efficient doubly linked list operations with full node control and traversal support.
Date Manipulation Class
A class designed for flexible date manipulation, featuring methods for formatting, comparison, and calendar calculations.
Input Validation Class
A structured class for safe user input handling with clean methods for reading, validating, and filtering data.
String Helper Class
A class for efficient string manipulation, with functions for text analysis, formatting, and transformation.
Utility Class
A utility class that offers general helper functions for numbers, arrays, vectors, and encryption.
File Handler Library
A foundational library providing modular functions for easy data storage and structured file I/O operations.
Rock-Paper-Scissors Game
1. Overview
The Rock-Paper-Scissors game is a simple C++ console project where the player competes against the computer. The gameplay is based on standard rules, and the computer's move is generated randomly each round.
The project focuses on practicing basic C++ concepts such as enums, functions, control flow, and user input handling. After several rounds, the program displays a clear summary of wins, losses, and draws. It’s a straightforward exercise that helped reinforce core logic and console interaction early in the learning process.
2. Learnings
Building this project improved understanding of loops, conditions, and structured programming in C++. It taught how to separate logic, apply randomization, and build interactive console programs.
3. Game Logic
- Player selects between Stone, Paper, or Scissors.
- Computer makes a random choice using
rand()andsrand(). - Each round determines a winner or a draw based on fixed rules.
- The program tracks total wins, losses, and draws.
- A color-coded result screen appears after every round.
4. Code Structure
- Enums:
enWinnerandenGameChoicedefine possible states. - Structs:
stRoundInfoandstGameResultsstore round data and totals. - Functions: Each feature is isolated into a simple reusable function.
- Randomization:
RandomNumber()ensures fair computer choices.
5. Techniques
Several techniques were used to make the gameplay smooth and stable:
- Input Validation: Ensures correct user entries by clearing input buffers with
cin.clear()andcin.ignore(). - Random Logic: Generates unpredictable computer choices using seeded randomness.
- Console Effects: Color changes and sounds provide instant feedback for each outcome.
- Structured Design: Each block of logic is separated for readability and maintainability.
6. Screenshots
7. Try The Project
Download the project as a ZIP folder and extract it. Once unpacked, you can run the program directly. Download it here.
8. Source Code
Visit the project repository on GitHub to view source code from here.
Math Quiz Game
1. Overview
The Math Quiz Game is a C++ console project that generates random arithmetic questions for the player. The difficulty level and type of operation can be selected before starting, and the game gives immediate feedback after each answer.
The project was built to practice control flow, random number generation, and basic input handling. At the end of the quiz, the program summarizes the player's score with a simple final report. It’s a straightforward exercise that helped reinforce problem-solving and structured function design.
2. Learnings
Creating this quiz improved understanding of control flow, struct usage, and procedural programming. It reinforced concepts of function design, random number handling, and user feedback systems. The project also showed how simple math logic can become a fun interactive experience.
3. Game Logic
- The player selects how many questions to answer, from 1 to 10.
- Levels include Easy, Medium, Hard, or Mix (a random combination).
- Operations include Addition, Subtraction, Multiplication, Division, or a mix of all.
- Each question is generated randomly with its correct answer stored for later comparison.
- Correct and wrong answers are tracked throughout the quiz, ending with a final score and pass/fail result.
4. Code Structure
- Structs:
sQuestionholds individual question data, andsQuizzmanages the overall session. - Enums:
enQuestionLevelandenOperationTypemake configuration simple and readable. - Functions: Small reusable functions handle question creation, user input, validation, and score calculation.
- Randomization: Questions and operations are randomized for a unique experience each time.
5. Techniques
- Validation: User inputs are checked to prevent invalid entries and ensure smooth gameplay.
- Color Feedback: Console colors change for correct and wrong answers to enhance interactivity.
- Random Generation: Uses seeded randomness with
srand()andrand()for fair variation. - Pass Criteria: The player must have more correct answers than wrong ones to pass.
6. Screenshots
7. Try The Project
Download the project as a ZIP folder and extract it. Once unpacked, you can run the program directly. Download it here.
8. Source Code
Visit the project repository on GitHub to view source code from here.
Library Management System
1. Overview
The Library Management System is a C++ console application that lets the user manage a small collection of books. It supports adding new books, viewing the list, borrowing and returning, and removing books when needed.
The project was made to practice working with structured data and menu-driven programs. Each book record stores basic details like ID, title, author, category, and whether it’s borrowed or available. The interface is simple and text-based, making it easy to test and understand how the system handles updates in real time.
2. Learnings
Working on this system helped me get more comfortable with organizing data using structs and vectors in C++. I also practiced building menu-based console programs and handling user input safely to avoid errors while navigating options. Overall, it was a good step toward understanding how small programs can manage and update records in a clear and consistent way.
3. Main Features
- Add Books: Register new books with a random ID, title, author name, and category.
- Display Books: Show all books with total count, borrowed status, and category information.
- Borrow and Return: Mark books as borrowed or returned while keeping the list updated.
- Remove Books: Delete books permanently from the collection.
- Categories: Supports Fiction, Science, History, Technology, and Art.
4. Code Structure
- Struct:
stBookInfostores book data including ID, title, author, category, and status. - Enums:
enOptionsandenBookCategorydefine menu choices and book types. - Functions: Each operation (add, borrow, return, remove) is handled by a dedicated function for clarity.
- Vector Container: Books are stored in a
<vector>for dynamic data handling.
5. Techniques
- Random ID Generation: Uses
rand()to assign unique IDs to new books. - Input Validation: Ensures valid menu choices and correct numeric inputs.
- Console Feedback: Color-coded output for success, errors, and general actions.
- Reusable Components: Functions are modular and can be reused in larger systems.
6. Screenshots
7. Try The Project
Download the project as a ZIP folder and extract it. Once unpacked, you can run the program directly. Download it here.
8. Source Code
Visit the project repository on GitHub to view source code from here.
Bank & ATM Management System
1. Overview
The Bank & ATM Management System is a C++ console project implemented using procedural programming. It handles basic banking operations such as storing client records, updating balances, and processing deposits and withdrawals.
The system uses simple text files to store client data, since this project was focused on logic and program flow rather than database integration. It includes two main modes: a Bank mode for managing accounts, and an ATM mode where a client can access and modify their own balance. The interface is menu-based and relies on clear control flow and file read/write operations to keep account information consistent across runs.
2. Learnings
Working on this project helped me get more comfortable building a larger program using procedural programming. I practiced organizing code into clear functions. I also learned how to store data using files, read it back safely, and update it without losing previous records. The login and menu parts reinforced how to guide the user through different program sections in a simple way.
3. System Flow
- The program starts with a secure login screen that validates user credentials stored in
Users.txt. - Depending on permissions, users can access the Bank System (for managing clients) or the ATM System (for financial operations).
- Client data, including balance and transaction history, is read from
Clients.txtandTrans.txt. - Every operation (add, withdraw, deposit, transfer) immediately updates the related text files to ensure consistency across sessions.
- The system provides clear text-based menus for navigation and real-time transaction feedback.
4. Code Structure
- Core Functions: The program is built around separate functions for each banking and ATM operation.
- Input Handling (in.h): Provides simple input validation to avoid crashes from invalid user entries.
- String Utilities (str.h): Used to split and process text lines when reading records from files.
- File Storage: Account and user data are stored in
.txtfiles and loaded into vectors while the program runs. - Procedural Style: The system uses functions instead of classes, with each function handling a single task to keep the flow easy to follow.
- Menu Navigation: Each section (Login, Bank Menu, ATM Menu) has its own function that routes user choices to the correct features.
5. Techniques
- Procedural Programming: The system is built using separate functions for each task instead of classes.
- Text File Storage: Data is saved and loaded using
<fstream>to work with plain text files. - Vectors for Data:
<vector>is used to store records in memory while the program is running. - Transaction Logging: Deposits and withdrawals are recorded in a simple log file for reference.
- User Login: The program checks stored username and password pairs before giving access.
- Menu-Based Navigation: The user moves through the system using clear, step-by-step console menus.
6. Screenshots
7. Try The Project
Download the project as a ZIP folder and extract it. Once unpacked, you can run the program directly. Download it here.
Use the default login info: Username: Admin , Password: 1234.
8. Source Code
Visit the project repository on GitHub to view source code from here.
Queue Line Management System
1. Overview
The Queue Line Management System is a C++ console project that simulates a basic waiting line. Each client receives a ticket number and is processed in the order they arrived, just like a service queue.
The project uses an object-oriented approach, where the clsQueueLine class manages adding clients, removing them when served, and showing the current queue status.
It’s a simple example of how a queue data structure can be applied in a real-use scenario.
2. Learnings
This project was one of the first steps in moving from procedural programming to object-oriented programming. Instead of writing separate functions everywhere, I learned how to group related data and behavior inside a single class. It also helped me understand queues more clearly by seeing how they work in a real usage scenario rather than just as a theory example. Using class methods to add and serve clients made the logic easier to follow and reuse in other projects later on.
3. System Flow
- The program starts with two example queues (Pay Bills and Account Services).
- Each queue is handled by its own
clsQueueLineobject. - When a client joins, the system issues a ticket with a number and timestamp.
- Clients are served in the same order they arrived (FIFO).
- After serving a client, the queue updates the next waiting position automatically.
- The console shows each ticket’s number, time, and current place in line.
4. Code Structure
- Main Class (clsQueueLine): The queue logic is grouped inside one class built on top of the standard
<queue>container. It handles adding clients, serving them, and showing the current queue state. - Ticket Struct: A small private struct stores each ticket’s number and timestamp so the queue data stays organized inside the class.
- Public Methods: The class exposes simple methods for creating a ticket, serving the next one, clearing the queue, and printing the current list. The internal queue remains private.
- Menu Layer: The console menu calls the class functions, keeping user interaction separate from how the queue works internally.
- Status Display: After each action, the program shows basic queue info like how many clients are waiting.
5. Techniques
- OOP Design: Encapsulation and inheritance organize queue logic and make it extendable.
- Queue Data Structure: Demonstrates practical application of FIFO principles in real-time service flow.
- Dynamic Statistics: Calculates total tickets, served clients, and average waiting time live.
- Formatted Output: Uses structured console printing to show queue data clearly and cleanly.
6. Screenshots
7. Try The Project
Download the project as a ZIP folder and extract it. Once unpacked, you can run the program directly. Download it here.
8. Source Code
Visit the project repository on GitHub to view source code from here.
Bank Management System
1. Overview
The Bank Management System is a C++ console application built using object-oriented programming. It manages client accounts, user permissions, and currency balances through a structured class-based design. Each part of the system (clients, users, currencies) is handled by its own class instead of one large procedural flow.
Data is stored in text files, and each class is responsible for loading and saving its own records. The program includes a simple login system, role-based access, and a menu interface for bank employees and administrators to manage accounts and perform transactions.
2. Learnings
This project helped me get comfortable organizing code using classes instead of one long procedural flow. I learned how to separate the user interface (screens) from the core logic, and how each class can be responsible for its own data. Working with text file storage and multiple modules showed me how different parts of a program can interact without becoming tangled. Overall, this project played a key role in my shift toward writing more structured and maintainable code.
It also reinforced core OOP concepts like keeping data private inside classes (encapsulation), sharing behavior through base screens (inheritance), and focusing each class on one clear responsibility.
3. System Flow
- Users log in through
clsLoginScreen, where credentials are checked usingclsUtil. - After login, permission flags determine what screens the user can access, such as client management, transactions, user accounts, or currency tools.
- Client records are stored in
Clients.txt. Screens likeclsFindClientScreenandclsUpdateClientScreenare used to search, update, add, or remove client data. - Employee accounts are stored in
Users.txt.clsUserandclsManageUsersMenuScreenhandle creating users, editing their permissions, and removing them when needed. - Login history and transfer operations are recorded in
LoginRegister.txtandTransferLog.txtso activity can be reviewed later. - Available currencies are managed by
clsCurrenciesusing data fromCurrencies.txt. Currency updates and conversions are accessed throughclsCurrencyCalculatorScreen.
4. Code Structure
- Core Classes:
clsBankClient,clsUser,clsCurrencies,clsScreen,clsDate, andclsUtil. Each class has a specific job: client and user classes hold account data, while the screen classes handle user interaction and system logic. - Screen Layer:
Several screen classes (such as
clsDepositScreen,clsTransferScreen,clsCurrencyCalculatorScreen, andclsTotalBalancesScreen) provide simple menu-driven interfaces that call the core class functions. - Data Layer:
The system stores records in text files and uses
<fstream>to read and write them:Clients.txt— client accounts and balances.Users.txt— employee login data and permissions.Currencies.txt— currency names and exchange rates.TransferLog.txt— logs money transfers between accounts.LoginRegister.txt— records login activity.
- Utility Layer:
Helpers used across the system:
clsUtil— formatting, encryption, and small helpers.clsString— splitting, trimming, and parsing text.clsDateandclsPeriod— date calculations and duration handling.
5. Techniques
- Full OOP Design: Over fifteen interlinked classes demonstrating inheritance, encapsulation, and abstraction.
- Text File Storage: Data is saved and loaded using
<fstream>with plain text files. - Encryption System: Passwords and sensitive data are encrypted and validated using
clsUtil. - Layered Architecture: Clear division between interface (screens), logic (classes), and storage (files).
- Bitwise Permissions: Access levels are defined using bitwise operations to grant or restrict user actions dynamically.
- Transaction Management: Realistic operations for deposit, withdrawal, balance check, and account-to-account transfer.
- Currency Module: Updates currency rates and performs basic conversion calculations.
6. Screenshots
7. Try The Project
Download the project as a ZIP folder and extract it. Once unpacked, you can run the program directly. Download it here.
Use the default login info: Username: Admin , Password: 1234.
8. Source Code
Visit the project repository on GitHub to view source code from here.
File Handler Library
1. Overview
This library provides a simple and reusable way to manage text files through a set of modular functions.
It supports operations like creating, reading, updating, and deleting records, all organized under the
fs namespace.
The goal was to understand how persistent data can be managed with clarity and structure.
2. Learning Reflection
Building this library taught me how to design reusable modules, handle file input/output safely, and think in terms of structured data management. It marked the early stage of developing a mindset focused on scalability, readability, and maintainable architecture.
The File Handler Library is one of the first libraries I built early in my C++ journey. It focuses on clean and structured file operations, helping programs handle text-based data efficiently.
3. Core Features
- Text to Struct Handling: Reads and writes data as structured records instead of raw text.
- Basic File Operations: Create, clear, copy, and print files using simple functions.
- Edit File Content: Add or remove lines and update existing records when needed.
- Load File to Memory: Read the entire file into a
std::vectorfor easy processing. - Search & Modify: Find and edit specific text inside file lines using straightforward parsing.
- Modular Design: All functions are grouped under the
fsnamespace for easy reuse.
4. Design Notes
The library is written entirely in standard C++ and uses headers such as
<fstream>, <vector>, and <string>
to manage files and data in memory.
It also includes a helper dependency str.h for splitting and parsing strings.
Each function is kept focused and independent, making the code base clean, readable, and easy to maintain.
5. Source Code
Visit the project repository on GitHub to view source code from here.
Utility Class
1. Overview
The clsUtil class is a general-purpose helper class written in C++ that collects commonly used functions in one place. It includes utilities for numbers, random generation, arrays, vectors, matrices, and simple text encryption.
The goal was to avoid repeating the same code across small projects and keep common operations in a single reusable module. This class was one of the first steps I took toward writing cleaner and more organized code.
2. Learning Reflection
Developing this class helped me learn how to organize related functionalities into one cohesive structure. It strengthened my understanding of static methods, modular programming, and efficient code reuse. It also served as an introduction to designing classes that act as general-purpose tools for larger software systems.
3. Core Functionalities
- Numeric Helpers: Small functions for checking primes, reversing numbers, and counting digit frequency.
- Random Tools: Generate random numbers, characters, or simple keys when needed.
- Array Helpers: Fill, copy, shuffle, and do basic checks on arrays.
- Vector Support: Simple functions for adding and displaying vector elements.
- Matrix Basics: Searching and summing values in small matrices (mainly for practice and learning).
- Simple Encryption: Basic character shifting for quick encode/decode needs.
4. Design Notes
The class uses standard C++ headers like
<iostream>, <vector>, <string>, and <ctime>
to handle computations and data manipulation efficiently.
Each method is static, allowing direct access without creating class instances.
This makes clsUtil lightweight and easy to integrate into other systems.
5. Source Code
Visit the project repository on GitHub to view source code from here.
String Helper Class
1. Overview
The clsString class is a small utility for common string operations in C++. It focuses on things like trimming spaces, changing letter case, counting words and characters, and splitting or joining text.
The goal was simply to avoid rewriting the same string-handling code across different projects. This class keeps those functions in one place so they’re easy to reuse and call when needed.
2. Learning Reflection
Working on this class helped me get more comfortable with text manipulation in C++. I practiced working directly with characters, splitting and combining words, and organizing these operations into clear, reusable functions. It also showed me how keeping related logic in one place can make the code easier to maintain and use in different projects.
3. Core Functionalities
- Word and Character Analysis: Count words, vowels, capital and small letters, and specific characters within text.
- Case Control: Convert text to uppercase, lowercase, or mixed case through structured methods.
- Text Cleaning: Remove punctuation, trim spaces, and normalize text formatting.
- Splitting and Joining: Split text into
<vector>elements or join them back with custom delimiters. - Word Replacement: Replace exact or case-insensitive words using clean and readable logic.
- String Reversal: Reverse text order while maintaining readability and structure.
4. Design Notes
The class is built using common C++ standard libraries such as
<string>, and
<vector>.
Most functions are declared as static, allowing them to be called directly without creating an object, which keeps usage simple.
The internal string value is stored in a single variable, and the methods operate on it or return processed results when needed.
5. Source Code
Visit the project repository on GitHub to view source code from here.
Input Validation Class
1. Overview
The clsInputValidate class provides simple functions to read and verify user input safely. It helps prevent crashes and unexpected behavior by making sure the input matches the required type before the program uses it.
The class includes methods for reading strings, characters, and numbers, along with checks for valid ranges. It centralizes input handling in one place, so the rest of the code stays clean and focused on logic instead of error checking.
2. Learning Reflection
Building this class deepened my understanding of safe user interaction and input validation in C++. It helped me learn how to handle input streams correctly, work with templates, and design reusable static methods that keep the main application logic clean and protected from user errors.
3. Core Functionalities
- Read Text and Characters: Simple functions for getting clean string or character input.
- Numeric Input: Reads integers and floating-point numbers safely without crashing on invalid input.
- Range Checking: Makes sure numbers fall within allowed limits when needed.
- Yes/No Handling: Converts user responses like "y/n" into clear boolean values.
- Template Support: Some functions use templates to work with different numeric types easily.
- Input Cleanup: Clears leftover input to prevent errors in repeated prompts.
4. Design Notes
The class is implemented with standard C++ headers such as
<iostream> and
<string>.
It uses templated functions to support different numeric types, ensuring reusability.
All methods are declared as static, allowing them to be called directly without object creation,
keeping the usage simple and efficient.
5. Source Code
Visit the project repository on GitHub to view source code from here.
Date Manipulation Class
1. Overview
The clsDate class provides a set of basic tools for working with dates in C++. It helps with creating dates, formatting them as text, and comparing them when needed.
The class includes functions for converting between string and date formats, checking valid dates, calculating differences, and determining the day of the week. It’s designed to make date-related logic easier to write and reuse across different small projects.
2. Learning Reflection
Building this class helped me understand how to handle time-based logic and calendar systems in C++. It strengthened my approach to structuring large sets of related functions into one coherent class and improved my ability to write scalable, precise algorithms that handle real-world date calculations correctly.
3. Core Functionalities
- Date Creation: Initialize dates from system time, string input, or day count since the year began.
- Formatting Tools: Convert between different date string formats with customizable patterns.
- Comparisons: Check if a date is before, after, or equal to another using precise logical checks.
- Arithmetic Operations: Increase or decrease dates by days, months, years, decades, or centuries.
- Calendar Display: Print monthly or yearly calendars directly to the console in an aligned format.
- Day Calculations: Count remaining days in a week, month, or year, and calculate days between two dates.
- Validation: Ensure that a date is valid within leap-year and month-day constraints.
- Business Logic: Identify weekdays, weekends, and calculate vacation return dates excluding weekends.
4. Design Notes
The class uses common C++ standard libraries such as
<iostream>,
<string>, and
<vector> for handling input and storing data.
Most functions are declared as static, so they can be used directly without creating an object, which keeps usage simple and consistent.
The internal date values are stored in a clear structure, and the methods operate on them or return results in straightforward formats.
5. Source Code
Visit the project repository on GitHub to view source code from here.
Doubly Linked List Class
1. Overview
The clsDblLinkedList class is a custom implementation of a doubly linked list in C++. It manages nodes manually using pointers, with direct control over both Head and Tail so elements can be accessed or modified from either direction.
The class was built to understand how linked lists work internally without using the STL. It includes basic operations such as inserting and removing nodes, searching for values, and looping through the list in forward or reverse order. Memory is managed manually, which helps reinforce how allocation and pointer connections work behind the scenes.
2. Learning Reflection
Developing this class from the ground up helped me gain deep insight into how linked lists work internally. I learned to manage pointers safely, prevent memory leaks, and implement bidirectional traversal logic. This project also improved my confidence in building complex data structures without relying on STL containers.
3. Core Functionalities
- Manual Pointer Control: Directly manages node connections using
HeadandTailpointers. - Insertion Methods: Add new nodes at the beginning, end, or after a specific index.
- Deletion: Remove nodes safely with pointer updates to maintain list integrity.
- Traversal: Move forward and backward through nodes for flexible data access.
- Search: Locate nodes by index or value with efficient pointer-based iteration.
- Reverse Operation: Reverse the list order by swapping node links manually.
- Template Support: Works with any data type through C++ templates for reusability.
4. Design Notes
The class is implemented using common C++ headers such as
<iostream> for basic input and output.
It defines a simple Node structure that holds the value and two pointers:
Next and Prev to allow moving forward and backward through the list.
Memory is handled manually using new and delete, which helps reinforce how dynamic allocation and pointer cleanup work in a linked list setup.
5. Source Code
Visit the project repository on GitHub to view source code from here.
Tic-Tac-Toe Game
1. Overview
Tic-Tac-Toe is a simple two-player desktop game built using C# and Windows Forms. The interface shows a 3×3 grid, and each player takes turns placing their symbol (X or O). The game updates the board instantly, checks for wins or draws, and lets you restart the match at any time.
The game supports both local two-player play and a basic computer opponent. The computer makes straightforward decisions based on the current board state, which keeps the gameplay smooth without overcomplicating the logic.
The win detection is done using a bitwise approach. Each square on the grid has a unique bit value, and each move adds that value to the player's bit pattern. The game then compares the player's pattern against pre-defined winning masks to check for a win quickly and cleanly, without looping over the board or writing long condition checks.
Before writing a single line of code, I designed this flowchart to outline the overall game logic. It clarified how the main conditions and player actions should flow, making the coding phase more organized and straightforward.
2. Learnings
After spending a solid phase building structured, console-based systems using procedural and object-oriented programming, I wanted to step into a new paradigm, event-driven programming. Working on a desktop application helped me understand how logic flows through user interactions rather than linear code execution. It taught me how every click, input, and visual update becomes an event that drives the entire program behavior.
I approached desktop development as a way to deeply understand the fundamentals of event-driven architecture which is a concept that exists across many modern technologies. Through this project, I learned to combine responsive UI design, structured logic, and real-time feedback, strengthening the link between user interaction and program logic.
3. System Flow
- MainForm: The game starts here, where the player chooses either Friend or Computer mode. Each button passes the selected mode through its
Tagproperty. - GameForm Initialization: All nine picture boxes are created and assigned unique bit flags through their
Tagvalues for bitwise tracking. - Player Move: When a player clicks a box, the program checks if that box is already taken using
TakenBoxes. - Board Update: If available, the clicked box image changes to X or O, and its bit flag is added to the corresponding player’s bit pattern using a bitwise OR operation.
- Result Check: After every move, the program compares the player’s current bit pattern against predefined winning combinations to detect a win or draw.
- Computer Mode: When enabled, the computer randomly selects one of the remaining untaken boxes and performs the same update and check sequence.
- Round End: If a player wins, the winning boxes are highlighted in green, the board is disabled, and the Next Round button becomes highlighted in green for restarting the match.
4. Code Structure
- MainForm: The main menu of the game. It displays two mode options — Friend or Computer — each button tagged with its mode and handled by a single click event that opens the
GameForm. - GameForm: Contains the entire gameplay logic. It draws the grid inside a
Panel, assigns bitwise tags to each picture box, handles all click events, updates player bit patterns, and checks for win or draw conditions. - Program: The entry point of the application. It initializes the Windows Forms environment and runs the
MainForm.
5. Techniques
- Bitwise System: Each box on the grid uses an
enumflag (1, 2, 4, 8, …, 256) stored in itsTag. The game combines these flags with bitwise OR operations and checks predefined masks with&to detect wins efficiently. - Unified Click Handler: A single event manages all nine picture boxes, simplifying logic and reducing repetitive code by using each box’s
Tagas a unique identifier. - GDI+ Drawing: The board grid is drawn directly inside the
Panelusing smooth, high-quality lines for a clean grid appearance. - Fixed Layout Design: The form uses a
FixedSingleborder style, disabled maximize button, and pixel-based font scaling to ensure identical proportions on different systems. - Round Management: The Next Round button resets all picture boxes, clears player and taken bits, resets labels, and increments the round counter for continuous play.
6. Game Modes
- Friend Mode: Two players take turns on the same device. The interface updates the Current Player label after every move, clearly showing whose turn it is.
- Computer Mode: The second player is controlled by the program, which automatically selects a random available box after the player’s turn and runs the same logic for move validation and win checking.
7. UI & Visuals
- Retro theme (black + neon yellow) with OCR A Extended headings.
- X/O assets swapped into picture boxes; winning line tiles turn green.
- Board grid drawn within the panel (not the form) for precise alignment.
8. Screenshots
9. Try The Project
Download the project as a ZIP folder and extract it. Once unpacked, you can run the program directly. Download it here.
10. Source Code
Visit the project repository on GitHub to view source code from here.
To-Do List App
1. Overview
To-Do List App is a small Windows desktop app for organizing everyday tasks. You can create categories, add tasks under each one, and mark tasks as done, reset them, or remove them when you're finished. The app stays simple on purpose, no database, no sync, no extra setup. It saves everything in a small local JSON file, so your tasks return exactly the same next time you open it.
2. Learning Highlights
I learned how to structure tasks using a Dictionary where each category holds its own list of tasks. I also practiced reacting to user actions directly in the UI, like marking tasks as done or resetting them. This was my first project using JSON for saving data, so I learned how to serialize and deserialize objects cleanly without needing a database, using the Newtonsoft.Json package from NuGet. Using small pop-up forms for adding and deleting categories also helped keep the main interface simple and easy to control.
3. Code Structure
- MainForm (Form): The main window that displays categories and tasks and handles actions like adding, completing, resetting, and removing tasks.
- AddCategoryForm (Form): A small pop-up used to create a new category. Once confirmed, the category is added to the Dictionary and appears immediately in the main UI.
- DeleteCategoryForm (Form): Allows the user to select a category to delete. After removal, the Dictionary is updated and the UI refreshes to reflect the change.
- Data Structure: Tasks are managed in a
Dictionary<string, List<TaskInfo>>, where each key is a category and the value is the list of tasks belonging to that category. - TaskInfo (Class): Represents a single task, including its text and completion state.
4. Features
- Create custom task categories.
- Add new tasks under each category.
- Mark tasks as done or reset them.
- Delete individual tasks when finished.
- Delete an entire category if it’s no longer needed.
- Select all or unselect all tasks with one action.
- Changes are saved automatically without needing a save button.
5. Data Storage
The app doesn’t use a database. It keeps all categories and tasks inside one small JSON file. Whenever you add, complete, reset, or delete a task, the app updates the file automatically so you don’t have to save anything manually.
When you open the app again, it reads that file and restores your tasks exactly the same as before. The file is stored locally in your user AppData folder:
C:\Users\(Username)\AppData\Local\ToDoList\tasks_data.json6. Screenshots
7. Try The Project
Download the project as a ZIP folder and extract it. Once unpacked, you can run the program directly. Download it here.
8. Source Code
Visit the project repository on GitHub to view source code from here.
Ajr – Daily Athkar Reminder
1. Overview
Ajr is a small Windows desktop app that shows short athkar reminders at regular intervals. It runs in the background and uses system tray notifications instead of interrupting the user. You can choose the type of Thikr and the time gap between reminders, and you can also choose whether the app starts automatically with Windows. The app saves your settings in a simple local JSON file so everything comes back the same next time you open it.
2. Learning Highlights
Working on Ajr taught me how to build a desktop app that runs in the background without getting in the user’s way. I also learned how to use controls like the NotifyIcon, balloon notifications, context menus, the Timer control, and how to use a UserControl as a mini-page inside the main form. I already used JSON in a previous project, but here I focused on applying it cleanly for saving and restoring user settings without overcomplicating the process. I also learned how to work with external UI libraries to add custom controls like styled buttons and panels instead of sticking to the default WinForms look.
3. Code Structure
- MainForm: The main window that switches between pages and manages the minimize-to-tray behavior.
- MainPage (UserControl): The main settings screen.
It contains the core controls used in the app:
- NotifyIcon: Keeps the app running in the system tray.
- Context Menu: Provides quick “Show / Exit” actions from the tray.
- ComboBoxes: Used to select the Thikr category and notification interval.
- Radio Buttons: Toggle notifications on/off and enable/disable startup behavior.
- Timer: Works with the NotifyIcon to show balloon notifications on a set interval.
- AboutPage (UserControl): A simple info screen with credits and a link to the developer’s website.
- AppSettings (Class): Handles saving and loading user preferences in a JSON file stored in AppData.
- categoriesData (Class): Provides the athkar grouped by category in a
Dictionary<string, List<string>>, which MainPage uses to choose a random Thikr for each notification. - Newtonsoft.Json (External Library): Used to write and read the settings JSON file easily.
- ReaLTaiizor (External UI Library): Used to add styled custom controls (like buttons and panels) for a cleaner UI instead of the default WinForms look.
4. Features
- Periodic athkar reminders through system tray balloon notifications.
- Runs silently in the background when minimized.
- Option to start automatically with Windows.
- Selectable Thikr categories.
- Customizable notification interval.
- Settings persist automatically across sessions.
5. Data Storage
The app doesn’t handle or store large amounts of data. It only saves the user's preferences (notification state, selected category, interval, and startup option) so the settings stay the same the next time the app is opened. These preferences are stored in a small JSON file located at:
C:\Users\(Username)\AppData\Local\Ajr\settings.json
The settings file records notification state, selected category, and timing interval, so the app restores everything exactly as it was when reopened without requiring any user intervention.
6. Screenshots
7. Try The App
Download the project as a ZIP folder and extract it. Once unpacked, you can run the program directly. Download it
here
8. Source Code
Visit the project repository on GitHub to view source code from here