How to install the Microsoft Windows operating system

Each version of Microsoft Windows is installed on a computer using similar steps. While there are steps in the installation process that differ between versions of Windows, the following general steps and guidelines help you install Windows on your computer.

If you are replacing the hard drive in your computer, you need to reinstall Windows again.

If you are replacing the motherboard in your computer, you may need to purchase a new licensed copy of Windows and install it. Microsoft has designed current versions of Windows to be tied to the motherboard in the computer when Windows is installed. So if you change the motherboard, the existing license, or product key, may no longer be valid.

If you want to upgrade to a newer version of Windows on your computer, the steps on this page help you with the upgrade process. The Windows installation process should recognize if you have an older version of Windows already installed on the computer and ask if you want to upgrade or perform a fresh install. The upgrade process installs the newer Windows operating system files over top the old ones and preserve your files.

The steps below are for all recent versions of Windows, including Windows 98, Windows ME, Windows 2000, Windows XP, Windows Vista, Windows 7, Windows 8, and Windows 10. These steps would even work for earlier versions (e.g., Windows 95) as long as you’re using the disc version. The floppy diskette version is similar, but it requires additional steps.

The install guidelines for Windows for a server have additional steps based on the type of server and version of Windows.

Check hardware compatibility

Before installing or upgrading Windows on your computer, check the hardware in the computer to make sure it’s compatible with that version of Windows. Microsoft provides a Windows Compatible Products List for checking if the hardware in your computer is compatible with the chosen version of Windows.

If you find that one or more pieces of hardware in your computer are not compatible with the chosen Windows version, we recommend replacing that hardware with compatible hardware. Having compatible hardware in your computer helps ensure the Windows install or upgrade process is successful.

Genuine Windows CD, DVD, or USB thumb drive

First, you need a genuine copy of the Microsoft Windows operating system installation CD, DVD, or USB thumb drive. A genuine Windows product key is included with the installation disc, which is required to activate Windows after installation. If you have an OEM computer, the Windows product key is often on the back or side of the computer.

If you have an OEM computer (e.g., Acer, Dell, HP, etc.), the computer will not have a genuine Windows CD, DVD, or USB thumb drive. Instead, you would reinstall Windows and all the software using a hidden partition or a set of restore discs. The steps mentioned on this page would still work, but you’d need a copy of Windows. You can borrow a friends Windows disc, as long as its the same version of Windows that came with the computer and have a product key.

With early versions of Windows, you cannot download a copy of Windows to install on a computer. You must purchase a physical copy of Windows. If you are installing Windows 10, you can download the Windows 10 creation tool to create a bootable disc or USB thumb drive.

Microsoft has Windows 10 available for download only from their website. Any other site that claims to have copies of other versions of Windows should not be trusted. These copies of Windows are pirated software and could contain anything including spyware or malware.

Installing or upgrading Windows

To start the Windows install or upgrade process, you need to configure your computer to boot from a CD or DVD before booting to the hard drive. Changing the boot process forces the computer to look for the Windows installation disc before trying to boot from the hard drive.

1. Open the CMOS setup.

• How to enter the BIOS or CMOS setup.

1. Change the computer’s boot order. Set the CD, DVD or disc drive as the first boot device if you are trying to boot from a disc. Or, set the first boot device to your USB drive if you’re trying to boot from a USB thumb drive. If the drive is not shown, keep the disc is inserted and reboot the computer. With the disc in the drive, BIOS should recognize and include it in the list.
2. Save the settings change and exit BIOS.

Once you have updated the boot order, you can begin the Windows installation process.

1. Place the Windows disc in the CD/DVD drive or USB thumb drive into the back of the computer.
2. Turn on or restart the computer. As the computer starts up, it should detect the installation disc or drive and show a message similar to Press any key to boot from CD. Press any key on the keyboard to have the computer boot from the Windows disc or drive.
3. After the Windows install begins, there are several prompts that you need to answer. Select either Yes or the appropriate option to install Windows.

Make sure you select the Full Install option and not the Repair or Upgrade option.

If you are upgrading to a newer version of Windows, select the Upgrade option instead of the Full Install option.

1. When asked which partition to install Windows onto, select the main partition, which is usually the C: drive or one labeled «Unallocated partition». If upgrading Windows, select the existing installation of Windows on the hard drive.
2. You may be asked if you want to erase all contents on the hard drive, then install Windows. We recommend you choose this option, as it also formats the hard drive to allow the Windows operating system to be installed.

You can use the erase all contents option to effectively uninstall an existing version of Windows on the hard drive, then install Windows agains.

1. The computer may need to restart several times during the Windows install process. The restarts are normal and if prompted to restart, select the Yes option.
2. When the install process is nearly complete, the Windows configuration option screens are shown. On these screens, you may be asked to select the time zone you live in, your preferred language, and the name of the account you use to access Windows. Select the appropriate options and enter the appropriate information on each configuration screen.

The Windows install process is completed when the computer prompts you to log in or when it loads into Windows.

Final Windows and computer configuration

After Windows is installed on the computer, you need to install the drivers and related software for the hardware in the computer. You can use the installation discs that came with the hardware, or you can download the drivers from the hardware manufacturer’s website.

If you cannot download drivers because your network card is not working after installing Windows, you can download the drivers on another computer. Then, copy them to a USB thumb drive, and move them over to your computer.

It is strongly recommended that you install the latest drivers for each piece of hardware.

To determine which hardware needs drivers to be installed, check the Device Manager and look for exclamation mark «!» next to hardware devices. The exclamation point means drivers are needed for that device.

After installing the necessary hardware device drivers, install any software programs on the computer that you want to use.

Finally, download and install any available Windows updates. Updating Windows improves the performance of the operating system, the hardware in the computer, and software programs you use. It can also improve security by fixing potential security holes and flaws in Windows.

Long-term maintenance of Windows

Microsoft frequently releases new updates for Windows, so we recommend you check for and install available updates. Doing so helps keep Windows running better and keep your computer protected.

Also, periodically check for updated hardware device drivers from manufacturers’ websites. Keeping hardware drivers updated helps the hardware devices in the computer run at peak performance and improves compatibility with other computer hardware and software.

Creating an Operating System

Welcome to operating systems development! This tutorial will document the process of creating a new operating system from the baby steps to creating a self-hosting operating system. The path is long and hard, but also fun and rewarding. As you progress through the stages, you will slowly begin to diverge from the tutorial as you make your own decisions about the design of your operating system and you no longer need this guide. If you create a non-Unix-like operating system, you will diverge earlier and will have to fill in the missing gaps yourself.

Contents

Phase 0: Introduction

Welcome to Operating Systems Development

You should consult all the basic documentation before starting writing an operating system.

Building the latest GCC

You may wish to upgrade your system compiler to the latest version before you start out with operating systems development and build the cross-compiler.

Phase I: Beginning

In this phase we will set up a toolchain and create a basic kernel that will become the core of the new operating system.

Setting up a Cross-Toolchain

The first thing you will like to do is set up a cross-compiler for your operating system. The compiler on your local system is not able to produce programs for your operating system because it hasn’t been invented yet. At first you would like to do is create a compiler that produces executables that will run directly on your target hardware.

Creating a Hello World kernel

Your next task is to make a simple hello world kernel that is able to start up, print a message to the output device and then loop endlessly. While simple and useless, it will serve as a great example and starting point for a real system, as well as confirm that your testing environment works correctly.

Setting up a Project

With a basic working example, your next task is to set up a build infrastructure using whatever build system you see fit. Be careful in your choices of technology, GNU Make is easier to port than Python.

Calling Global Constructors

The compiler expects you to perform various program initialization tasks, such as calling the constructors on global C++ objects. Normally you would use a kernel_early_main function to set up the minimal kernel features, then perform all these initialization tasks, and then jump to the actual kernel_main function.

Terminal Support

You will often need to debug your operating system. Your very best friend is a printf function that is able to print strings and integers to the screen onto a terminal-like buffer. It is crucial to add a printf function to your kernel early on as you will certainly need it later for debugging.

Stack Smash Protector

Early is not too soon to think about security and robustness. You can take advantage of the optional stack smash protector offered by modern compilers that detect stack buffer overruns rather than behaving unexpectedly (or nothing happening, if unlucky).

Multiboot

It’s useful to know what features and information the bootloader offers the kernel, as this may help you get memory maps, set video modes, and even kernel symbol tables.

Global Descriptor Table

The Global Descriptor Table is an important part of the processor state and it should as such be one of the first things that are initialized. It probably makes a lot of sense to set up it even prior to kernel_early.

Memory Management

Memory allocation and management is one of the most basic functions in an operating system. You need to keep track of physical page frames, what ranges of virtual memory are used, and implementing a heap (malloc, free) upon it for internal kernel use.

Interrupts

Your kernel needs to handle asynchronous events sent by the hardware to function properly.

Multithreaded Kernel

It is best to go multithreaded early in the development of your kernel or you’ll end up rewriting parts of your kernel. We’ll certainly need this when we add processes later on.

Keyboard

Your operating system will certainly need support for reading input from the computer operator so it can adapt its behavior to his wishes.

Internal Kernel Debugger

It is very useful for a multithreaded kernel to have built-in debugging facilities early on. You could have a magic key that stops the entire kernel and dumps the user to a mini-kernel with a command line interface for debugging. It could know the data structures used by the scheduler to list all the threads and perform call traces.

Filesystem Support

It’ll be useful to have support for filesystems early on and transferring files onto your operating system using a initialization ramdisk.

Phase II: User-Space

In this phase we’ll expand your operating system into user-space and add support for programs, which is enough for your project to qualify as a small operating system. You need to work on system calls, program loading, memory management and rework parts of your system early in this phase.

User-Space

Your procesessor has until now run in kernel mode, where the code is able to do everything. Processes are normally run with no permissions at all, except being able to execute code and use its designated memory. The first part of implementing user-space is switching the processor to user mode.

Program Loading

The first task you will need to complete is loading a program into memory. This involves parsing the program headers, allocating memory at the right virtual addresses and copying the contents of the segments to the right virtual addresses. You’ll also need to fill up entries in the GOT according to the relocation tables.

System Calls

You are now able to load programs into memory and switch to use mode. Processes communicate with the kernel using system calls, which is the next feature you will want to add.

OS Specific Toolchain

As your operating system is now becoming a real operating system, it is time to treat it as such. We’ll like to teach the cross-compiler about your operating system and its conventions, so we can easily cross-compile programs.

Creating a C Library

At this point, you can decide to use an existing C library or write your own C library. If you go the custom route, you will want to set up some basic features that the cross-compiler needs for libgcc. With this in place, you can now easily cross-compile programs.

Fork and Execute

With basic program loading in place, we are almost ready to create a multitasking operating system. The missing primitives is allowing a process to create new processes. The standard Unix primitive is fork, which allows a process to create a perfect copy of itself. This copy is then able to call the program loader and replace its own memory with that of another program image.

Shell

This is a very exciting point in your operating system. It is able to run programs and create new processes. So far, the behavior of the system has possibly been determined when it was compiled. By writing a shell, you can run multiple programs and decide which one to run at runtime. This is the point where you reach the level that many newcomers dream of: a basic operating system with a working command line.

Phase III: Extending your Operating System

With these basic features in place, you can now start writing your operating system and all its wonderful features. You’ll add games, editors, test programs, command line utilties, drivers and whatever you can imagine. Your skill and imagination is the limit here. You can delay many of these features until later in your operating system and make then in almost any order.

Time is a complicated concept in computing, however modern operating systems are expected to have functions for converting timestamps to parsed time and back, as well as providing system clocks (real time, monotonic time, user CPU time, ..) and timers on these clocks with events happening on expiration.

Threads

Operating systems should expose a threading API such as pthreads.

Thread Local Storage

Thread local variables require runtime support.

Symmetric Multiprocessing

It’s a very good idea to add support for multiple CPUs to your kernel early on, or you will likely need to redo a lot of your kernel because it wasn’t SMP-ready in many places.

Secondary Storage

You will likely want to support common block devices such as harddisks, cdroms, floppies, and whatever storage devices your operating system needs support for.

Real Filesystems

It’s a good idea to add proper filesystem support early on.

Graphics

Real operating systems don’t operate in the basic text mode, but have bitmapped graphics. Writing real graphics drivers is a bunch of work, although some virtual machines offer some useful shortcuts.

User Interface

You will certainly need to impress the operating systems development community with your flashy graphics and usable user-interface.

Networking

The uses for networking support are obvious, so you will likely want to do this.

Sound

Sound is an important part of the computing experience and depending on your needs, you may well wish to support sound on common hardware.

Universal Serial Bus

If you need to communicate with modern peripherals, you will likely need a USB stack and support for the various common USB controllers.

Phase IV: Bootstrapping

You now have your basic operating system in place and you are ready to move onto the next level. In this phase, we will start porting software onto your operating system such that you can become self-hosting. You already begun your effort toward being self-hosting when you set up your OS-specific toolchain and it pays off now.

Porting Software

While not all pieces of software is easy to port, most Unix software comes with a autoconf-generated configure script. You can provide these scripts with the —host=mycpu-myos option and if your operating system offers the needed features, you can cross-compile the software onto your operating system. You already met examples of how to port software when setting up the OS-specific toolchain. While the difficulity of cross-compiling software differs greatly, you will like be using the same process for adapting new packages.

Porting GCC

You already began the work porting binutils and gcc when you set up the OS-specific toolchain. We’ll finish the process and cross-compile them onto your operating system such that it can compile the C hello world program.

Compiling your OS under your OS

The next task is to port your entire build system. You may need to port GNU Make, port some command line utilites (coreutils) or write your own, port a real shell or finish yours and more. You may also need to fix a number of bugs in your operating system such that the compiler runs correctly. You will need to deal with how to transfer the newly compiled version onto permanent storage such that a reboot of the computer will run the next version. Your operating system will now quality as self-compiling.

Fully Self-hosting

Now that you can build your entire operating system under your operating system, you also need to be able to do the rest. You need to be able to also build your compiler under your operating system. You need to be able to develop under your operating system, so you’ll port your favorite text editor or write one. You need networking so you can release the newest version (build on itself) onto the internet. You’ll port lots of programs, libraries, games, and whatever else you desire, such that the entire development process can happen on your operating system. You can now uninstall your original operating system and replace it with your new glorious operating system.

Phase V: Profit

You have now successfully created a real operating system that is fully self-hosting and the envy of the entire operating systems development community. You have ported quake, have OpenGL programs, a working browser, a thriving community of contributors, and much success. You can now start over and develop the next operating system from your own operating system.