A SYNOPSIS ON

Virtual Operating System

Submitted in partial fulfilment of the requirement for the award of the degree of

BACHELOR OF TECHNOLOGY
In
Computer Science & Engineering

Submitted by:
Ayush Budhlakoti 2261123
Deepanshu Suyal 2261176
Mitali Pandey 2261365
Deepak Chandola 2261167

Under the Guidance of

Mr. Ansh Dingra
Assistant Professor

Project Team ID: 66

Department of Computer Science & Engineering

Graphic Era Hill University, Bhimtal, Uttarakhand
March-2025

pg. 1
CANDIDATE’S DECLARATION

I/We hereby certify that the work which is being presented in the Synopsis entitled “Virtual OS” in
partial fulfilment of the requirements for the award of the Degree of Bachelor of Technology in
Computer Science & Engineering of the Graphic Era Hill University, Bhimtal campus and shall be
carried out by the undersigned under the supervision of Mr. Ansh Dingra, Assistant Professor,
Department of Computer Science & Engineering, Graphic Era Hill University, Bhimtal.

Ayush Budhlakoti 2261123

Deepanshu Suyal 2261176
Mitali Pandey 2261365
Deepak Chandola 2261167

The above mentioned students shall be working under the supervision of the undersigned on the
“Virtual OS”

Signature Signature
Supervisor Head of the Department

Internal Evaluation (By DPRC Committee)

Status of the Synopsis: Accepted / Rejected

Any Comments:

Name of the Committee Members: Signature with Date

1.
2.

pg. 2
Table of Contents

Chapter No. Description Page No.

Chapter 1 Introduction and Problem Statement 4

Chapter 2 Background/ Literature Survey 6

Chapter 3 Objectives 9

Chapter 4 Hardware and Software Requirements 10

Chapter 5 Possible Approach/ Algorithms 11

References 15

pg. 3
 Chapter 1

Introduction and Problem Statement

Introduction

Operating Systems (OS) are the backbone of modern computing, managing hardware
resources, executing processes, and handling files efficiently. A Virtual Operating System
(VOS) is a simplified simulation of an OS that replicates fundamental functionalities such as
Process Management, Memory Management, and File Management. This project
provides a hands-on understanding of how an OS works internally by allowing users to
create, manage, and terminate processes, allocate and deallocate memory, and perform file
operations through a command-line interface and a graphical interface built with Streamlit.

This Virtual OS does not directly interact with the actual hardware but simulates OS behavior
using Python, making it a great learning tool for students and developers interested in
Operating Systems.

Problem Statement

Operating Systems are complex software systems that require deep knowledge of process
scheduling, memory allocation, and file handling. However, understanding these concepts
can be challenging due to their low-level nature and dependency on system-specific
implementations.

This project aims to address the following challenges:

 Lack of Hands-on Learning: Many learners struggle to understand OS concepts

without a practical implementation.

 Complexity of Real OS Development: Developing a full-fledged OS requires kernel

programming, which is highly complex and system-dependent.

 Need for a Simplified OS Simulation: A lightweight, Python-based virtual OS can

help users grasp OS fundamentals without needing extensive knowledge of low-level
system programming.

Objectives of the Virtual Operating System (VOS):

Provide a Process Management System to create, terminate, and schedule processes.

Implement Memory Management using paging techniques to allocate and deallocate memory
dynamically.

pg. 4
Develop a File System that allows basic file operations like create, read, write, and delete.

Build a User Interface (UI) using Streamlit for better user interaction.

This project serves as an educational tool to bridge the gap between OS theory and real-world
implementation.

pg. 5
 Chapter 2

Background/ Literature Survey

An Operating System (OS) is a system software that manages computer hardware, software
resources, and provides services for computer programs. It serves as an intermediary between
users and the computer hardware. Some of the well-known operating systems include
Windows, Linux, macOS, and Unix.

The primary functions of an OS include:

 Process Management (Creating, scheduling, and terminating processes)

 Memory Management (Allocation and deallocation of memory)

 File System Management (Handling file operations like read, write, and delete.

 Device Management (Managing hardware resources)

1. Virtual Operating System Concept

A Virtual Operating System (VOS) is a software-based simulation of an operating system

that replicates essential OS functionalities without interacting directly with hardware at a low
level. Unlike real operating systems that require kernel development, a VOS can be
implemented using high-level programming languages such as Python, allowing users to
grasp OS fundamentals in a controlled environment.

2. Literature Survey and Related Work

2.1 Traditional Operating Systems

Several real-world operating systems, including Windows, Linux, and macOS, have been
developed over the years. These operating systems follow monolithic, microkernel, or hybrid
architectures, and their development involves:

 Kernel programming (C, C++, Assembly)

 Process scheduling algorithms (FCFS, Round Robin, etc.)

 Memory management techniques (Paging, Segmentation, etc.)

pg. 6
Building a full-fledged OS from scratch is highly complex, requiring low-level programming,
bootloader development, and hardware interaction.

2.2 Existing Simulations & Virtual OS Implementations

Various simplified OS models have been developed for educational purposes, including:

 Nachos (Not Another Completely Heuristic Operating System)

 A simulation of an OS designed for students to understand threading,

file systems, and system calls.

 Implemented in C++, making it more complex for beginners.

 Xv6 (Unix-like Teaching Operating System)

 A simple Unix-like OS written in C, used in OS courses at MIT.

 Provides an in-depth understanding of OS internals but requires kernel

programming knowledge.

 TinyOS (Embedded OS for Sensor Networks)

 A lightweight OS developed for IoT devices, primarily written in NesC

(a dialect of C).

Although these models are useful for academic purposes, they are often too complex for
beginners who want to understand OS concepts without diving into kernel development.

3. Justification for the Virtual Operating System (VOS) Project

Given the challenges in understanding real-world operating systems, a Python-based Virtual

OS provides a simplified and interactive learning experience. The VOS Project stands out
due to:

 Ease of Implementation: Uses Python, making it accessible for students and

beginners.

 Process Simulation: Implements basic process scheduling without requiring actual

hardware execution.

 Memory Management: Simulates paging-based memory allocation without

modifying system-level memory.

 File Operations: Implements basic file operations within a sandboxed environment.

 User Interface: Unlike traditional CLI-based OS models, VOS provides a Streamlit

GUI, making interactions more user-friendly.

pg. 7
By bridging the gap between OS theory and practical implementation, the Virtual Operating
System (VOS) serves as a valuable educational tool for students, developers, and enthusiasts
interested in operating system concepts.

pg. 8
 Chapter 3

Objectives
Objectives of the Virtual Operating System (VOS) Project

The Virtual Operating System (VOS) aims to simulate fundamental operating system
functionalities using Python. The project is designed to provide an interactive learning
experience, focusing on process management, memory management, and file system
operations. The following are the key objectives:

1. Process Management

Implement process creation, execution, and termination.

Simulate First-Come-First-Serve (FCFS) or Round Robin scheduling.
Maintain a process table to track active processes.

2. Memory Management

Implement dynamic memory allocation and deallocation.

Simulate memory paging to manage memory efficiently.
Display real-time memory usage through a graphical interface.

3. File System Management

Enable file operations such as create, read, write, append, and delete.
Maintain a virtual directory structure for file storage.
Implement file access permissions for controlled access.

4. User Interface (GUI with Streamlit)

Develop an interactive and user-friendly GUI using Streamlit.

Provide separate tabs for process, memory, and file management.
Display logs and system status in real time.

5. Security and Isolation

Ensure safe execution of processes in a controlled environment.

Implement sandboxing techniques to prevent unauthorized access to the system.
Provide error handling and exception management to prevent crashes.

6. Educational and Practical Learning

Help students understand basic OS concepts through a working simulation.

Bridge the gap between theory and practical implementation of operating systems.
Provide a modular and extensible code structure for future improvements.

pg. 9
 Chapter 4

Hardware and Software Requirements

3.1 Hardware Requirements

Sl. No Name of the Hardware Specification

1 Processor Intel Core i5/i7 (or equivalent)

2 RAM 8GB or higher

3 Internet Required for updates

3.2 Software Requirements

Sl. No Name of the Software Specification

1 Python Main programming language

2 Text Editor/IDE VS Code, PyCharm, Jupyter Notebook

3 Streamlit Latest version

pg. 10
 Chapter 5

Possible Approach/ Algorithms

Possible Approaches & Algorithms for the Virtual Operating System (VOS) Project

The Virtual Operating System (VOS) consists of three major components: Process
Management, Memory Management, and File System Management. Below are the
possible approaches and algorithms used for each module.

Process Management
Approach:
Processes are simulated using a Process Table, which stores details like Process ID (PID),
Process Name, Status (Running/Waiting/Terminated), and Execution Time. A simple
scheduling algorithm is used to manage multiple processes.

Algorithms Used:

 First-Come-First-Serve (FCFS) Algorithm

o The simplest scheduling algorithm.

o Processes are executed in the order they arrive.

o Implementation: Maintain a queue where the first process added is executed

first.

o Time Complexity: O(n)O(n), where nn is the number of processes.

 Round Robin (RR) Algorithm (Optional)

o Each process is assigned a fixed time slice (quantum).

o The CPU cycles through processes, switching after each time slice.

o Implementation: Use a circular queue. If a process doesn’t finish in its time

slice, it moves to the end of the queue.

o Time Complexity: O(n)O(n).

pg. 11
Memory Management
Approach:

Memory allocation is managed using a paging system, where memory is divided into fixed-
size blocks (pages). Each process gets allocated pages based on its requirements.

Algorithms Used:

 Paging Algorithm

o Simulates memory allocation by dividing memory into fixed-size

frames. Each process is assigned non-contiguous memory blocks.

o Implementation: Maintain a page table that maps logical addresses to physical

addresses.

o Time Complexity: O(1)O(1) for allocation and lookup.

 First-Fit Memory Allocation

o Searches for the first available memory block large enough for the process.

Implementation: Iterate through memory blocks and allocate the first suitable

one. Time Complexity: O(n)O(n) in worst case.

 Best-Fit Memory Allocation (Optional)

o Searches for the smallest memory block that fits the process size.

Implementation: Sort memory blocks by size and allocate the smallest

available. Time Complexity: O(nlog⁡n)O(n \log n) due to sorting.

 Memory Deallocation

o When a process terminates, its allocated memory is

released. The free memory list is updated to reflect

available space.

pg. 12
 File System Management
Approach:
A virtual file system is implemented using a directory structure where files can be created,
read, written, and deleted.

Algorithms Used:

Indexed File Allocation

Each file has an index block that stores addresses of all its data blocks.

 Implementation: Maintain an index table mapping file names to block addresses.

 Time Complexity: O(1)O(1) for lookup.

 Contiguous File Allocation (Optional)

Files are stored in consecutive memory locations.

o Implementation: Allocate a continuous memory segment to a file upon

creation.

o Time Complexity: O(n)O(n) in worst case.

 File Permissions & Access Control (Optional)

o Each file is assigned permissions (read, write,

execute). Users must have proper permissions to

access a file.

UI Implementation (Streamlit)
Approach:

A Graphical User Interface (GUI) using Streamlit allows users to interact with the Virtual
OS.

Tabs for Process Management, Memory Management, and File System

Operations.

Displays system status and logs for better visualization.

References

 Abraham Silberschatz, Peter B. Galvin, Greg Gagne – Operating System Concepts

pg. 13
 (9th Edition)

Covers fundamental OS concepts including process scheduling, memory

management, and file systems.

 Andrew S. Tanenbaum, Herbert Bos – Modern Operating Systems (4th Edition)

Provides a deepdive into OS architectures, including process synchronization and

paging techniques.

 William Stallings – Operating Systems: Internals and Design Principles (8th Edition)

Explains memory allocation strategies, file system structures, and OS design

principles.

 Nachos OS (Not Another Completely Heuristic Operating System)

A simplified OS simulation used for educational purposes.

Source: https://inst.eecs.berkeley.edu/~cs162/sp20/projects/project-2/

 Xv6 - A Unix-like Teaching Operating System

A minimal OS designed for teaching OS fundamentals at MIT.

Source: https://pdos.csail.mit.edu/6.828/2021/xv6.html

 Linux Kernel Documentation

Useful for understanding real-world OS implementation concepts.

Source: https://www.kernel.org/doc/html/latest/

 Python Official Documentation – https://docs.python.org/3/

For understanding Python’s capabilities in process handling, memory management,

and file I/O.

 Streamlit Documentation – https://docs.streamlit.io/

For implementing a GUI-based interface for the Virtual OS.

pg. 14
pg. 15