Skip to content
BranchesTags

Repository files navigation

🖥️ OS Visualiser

OS Visualiser

An Interactive Web-Based Operating System Simulator for Visualizing Core OS Concepts and Algorithms

Learn Operating System concepts through real-time visualizations, interactive simulations, and hands-on experimentation.

🚀 Live Demo

Experience the project directly in your browser.

🌐 https://himanshusinghpatel998.github.io/os_visualiser/

No installation is required.

📖 About the Project

OS Visualiser is an interactive educational platform designed to simplify Operating System concepts through dynamic visualizations and simulations.

Traditional Operating System learning relies heavily on static diagrams and theoretical explanations. This project transforms those concepts into interactive simulations where users can provide custom inputs, observe algorithm execution step-by-step, and analyze the generated results in real time.

The application is completely browser-based and covers major Operating System topics including CPU Scheduling, Process Synchronization, Deadlock Handling, Memory Management, Page Replacement, Disk Scheduling, File Allocation, and Directory Structures.

It is designed for:

  • 🎓 Computer Science Students
  • 👨‍🏫 Educators
  • 💼 Technical Interview Preparation
  • 📚 Self Learning
  • 💻 Operating System Enthusiasts

🎯 Project Objectives

  • Visualize Operating System algorithms interactively.
  • Make complex OS concepts easier to understand.
  • Encourage learning through experimentation.
  • Build a modular and scalable educational platform.
  • Provide a practical resource for academic learning and interview preparation.

📊 Project Highlights

  • ✅ 20+ Operating System algorithms implemented
  • ✅ 9+ interactive learning modules
  • ✅ Browser-based execution
  • ✅ Dynamic visualization of algorithms
  • ✅ Real-time performance metric calculation
  • ✅ Interactive user interface
  • ✅ Modular architecture
  • ✅ Responsive design
  • ✅ Live deployment using GitHub Pages

✨ Features

  • Interactive algorithm simulations
  • Dynamic Gantt Chart generation
  • User-defined inputs
  • Automatic metric calculation
  • Real-time visualization
  • Clean and responsive interface
  • Modular implementation
  • Beginner-friendly design
  • No external dependencies
  • Easy deployment

📚 Modules Implemented

🧩 System Calls

Visualizes commonly used system calls and demonstrates process creation and execution.

Implemented:

  • fork()
  • exec()
  • wait()
  • exit()

Concepts Covered:

  • Parent-child process creation
  • Process execution
  • Process synchronization
  • Process lifecycle

⚙️ CPU Scheduling

Simulates multiple CPU Scheduling algorithms with customizable process inputs.

Algorithms:

  • First Come First Serve (FCFS)
  • Shortest Job First (SJF)
  • Shortest Remaining Time First (SRTF)
  • Round Robin
  • Priority Scheduling (Preemptive)
  • Priority Scheduling (Non-Preemptive)

Generated Metrics:

  • Gantt Chart
  • Completion Time
  • Waiting Time
  • Turnaround Time
  • Response Time
  • Average Waiting Time
  • Average Turnaround Time

🤝 Process Synchronization

Interactive visualization of classical synchronization problems.

Implemented:

  • Producer Consumer
  • Readers Writers
  • Dining Philosophers

Concepts Covered:

  • Critical Section
  • Mutual Exclusion
  • Semaphores
  • Resource Sharing
  • Synchronization

🚦 Deadlock Handling

Simulates deadlock management strategies.

Implemented:

  • Banker's Algorithm
  • Deadlock Detection Algorithm

Features:

  • Safe Sequence Detection
  • Resource Allocation
  • Need Matrix
  • Available Matrix
  • Safe State Analysis

💾 Memory Management

Memory allocation using partitioning techniques.

Implemented:

  • Multiple Fixed Partitions (MFT)
  • Multiple Variable Partitions (MVT)

Concepts Covered:

  • Internal Fragmentation
  • External Fragmentation
  • Partition Allocation
  • Memory Utilization

📦 Contiguous Memory Allocation

Algorithms:

  • First Fit
  • Best Fit
  • Worst Fit
  • Next Fit

Visualizes:

  • Memory Allocation
  • Remaining Memory
  • Fragmentation
  • Free Memory Blocks

🧠 Page Replacement Algorithms

Implemented:

  • FIFO
  • Optimal
  • LRU
  • LFU

Generated Metrics:

  • Page Hits
  • Page Faults
  • Hit Ratio
  • Fault Ratio
  • Memory Frames

💽 Disk Scheduling

Implemented:

  • FCFS
  • SSTF
  • SCAN

Displays:

  • Seek Sequence
  • Total Seek Time
  • Disk Head Movement

🗃️ File Allocation

Implemented:

  • Sequential Allocation
  • Linked Allocation
  • Indexed Allocation

📁 Directory Structures

Implemented:

  • Single-Level Directory Organization

🏗️ Architecture

The project follows a modular architecture where every Operating System concept is implemented independently.

Advantages:

  • Easy maintenance
  • Reusable code
  • Independent module development
  • Improved scalability
  • Better readability
  • Simplified debugging

🛠️ Tech Stack

Category Technology
Frontend HTML5
Styling CSS3
Programming JavaScript (ES6)
Deployment GitHub Pages
Version Control Git & GitHub

📂 Project Structure

os_visualiser/
│
├── assets/
├── css/
├── images/
├── js/
│
├── cpu_scheduling/
├── system_calls/
├── process_synchronization/
├── deadlock/
├── memory_management/
├── contiguous_memory_allocation/
├── page_replacement/
├── disk_scheduling/
├── file_allocation/
├── directory_structure/
│
├── index.html
└── README.md

🚀 Getting Started

Clone the Repository

git clone https://github.com/himanshusinghpatel998/os_visualiser.git

Move into the project directory.

cd os_visualiser

Run the application by opening index.html in your browser or using VS Code Live Server.

🎮 How to Use

  1. Open the application.
  2. Select an Operating System module.
  3. Enter the required inputs.
  4. Run the simulation.
  5. Observe the visualization and generated metrics.
  6. Compare different algorithms.

💡 Challenges Solved

  • Dynamic Gantt Chart generation
  • Real-time metric calculation
  • Interactive visualization of complex OS algorithms
  • Modular JavaScript implementation
  • Responsive user interface
  • Reusable component-based structure

🎯 Learning Outcomes

This project demonstrates practical implementation of:

  • CPU Scheduling
  • Process Management
  • Synchronization
  • Deadlock Handling
  • Memory Management
  • Page Replacement
  • Disk Scheduling
  • File Systems
  • DOM Manipulation
  • Event-Driven Programming
  • Modular Software Design

🚀 Future Enhancements

  • Multi-Level Queue Scheduling
  • Multi-Level Feedback Queue Scheduling
  • LOOK Disk Scheduling
  • C-LOOK Disk Scheduling
  • C-SCAN
  • Buddy Memory Allocation
  • Segmentation
  • Paging with Segmentation
  • Tree Directory Structure
  • Performance Comparison Graphs
  • Dark Mode
  • Export Simulation Results

🤝 Contributing

Contributions are welcome.

  1. Fork the repository.
  2. Create a feature branch.
  3. Commit your changes.
  4. Push the branch.
  5. Open a Pull Request.

📄 License

This project is licensed under the MIT License.

👨‍💻 Author

Himanshu Singh Patel

GitHub: https://github.com/himanshusinghpatel998

Live Demo: https://himanshusinghpatel998.github.io/os_visualiser/

⭐ Support

If you found this project useful, consider giving it a Star ⭐ on GitHub.

It helps others discover the project and motivates future improvements.

About

Interactive web-based Operating System simulator featuring 20+ OS algorithms with real-time visualizations for CPU Scheduling, Memory Management, Process Synchronization, Deadlock Handling, Page Replacement, Disk Scheduling, and File Allocation.

himanshusinghpatel998.github.io/os_visualiser/

Topics

algorithmscpu-scheduling-algorithmscssdeadlock-tooldisk-schedulinghtmljavascriptmemory-managementoperating-systemospage-replacementprocess-synchronizationpythonsimulatorvisualizer

Resources

Readme
Activity

Stars

2 stars

Watchers

1 watching

Forks

1 fork
Report repository

Releases

Packages

Used by

Contributors

Languages