Open-source project
SinaKarvandi/Hypervisor-From-Scratch avatar
SinaKarvandi/Hypervisor-From-Scratch

Hypervisor From Scratch: eight tutorial drivers, one Windows toolchain, no releases

Source code of a multiple series of tutorials about the hypervisor. Available at: https://rayanfam.com/tutorials

2,686 stars365 forksCMIT

At a glance

What is it?
Eight part directories of C that build Windows drivers from entering VMX operation to virtualizing an already running system, with Visual Studio and the Windows Driver Kit as the only documented build path.
Who is it for?
Read it as a course rather than a dependency: the drivers exist to be read next to the tutorial pages, the repository ships no binary to install, and its own note tells you not to build anything real on the early parts. Before trusting a specific part, check commit history for what changed after the August 2022 revision and whether your setup matches the part you need, since Hyper-V nested virtualization is only covered from part 8.
Can I use it commercially?
Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Activity is slowing. The repository last received commits 6 months ago.
What is it written in?
Mainly C, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 13, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • SinaKarvandi/Hypervisor-From-Scratch2,686 ★ · +15
Star history
Repository2026-10-042026-11-13
SinaKarvandi/Hypervisor-From-Scratch2.7k2.7k

15 Stars in the last 40 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

Eight part directories and no build file at the root

The top level of the repository holds one directory per tutorial part, and each directory name is the part title itself: Part 1 - Basic Concepts & Configure Testing Environment, Part 2 - Entering VMX Operation, Part 3 - Setting up Our First Virtual Machine, Part 4 - Address Translation Using Extended Page Table (EPT), Part 5 - Setting up VMCS & Running Guest Code, Part 6 - Virtualizing An Already Running System, Part 7 - Using EPT & Page-level Monitoring Features, and Part 8 - How To Do Magic With Hypervisor. Alongside them sit .gitignore, LICENSE, README.md and an images folder. What is absent is just as informative: no build script, no solution file, no CI directory and no shared project file. Nothing at the root builds all eight drivers at once, so a reader who wants part 6 opens the part 6 directory and builds that driver alone. The naming also means a part's code lives in its own directory, which removes the temptation to treat the eight as one evolving codebase. That matters once the project's own note about not reusing early parts is taken seriously: the directory list never marks which part is current, and only the commit history carries that signal. The project describes itself in one line as source code for a series of tutorials about the hypervisor, published at https://rayanfam.com/tutorials, and the language recorded for the repository is C with master as the default branch. Those facts explain the layout: the code is meant to be read beside the tutorial text, and the directory names are indexes into that text rather than modules of a shipped application.

The toolchain is Visual Studio and the WDK, with no command to copy

The Compile & Install section is short: install Visual Studio, then install the Windows Driver Kit, and after that you can compile. No command line appears in it, and the repository ships no script to run instead. That follows from what the code is: the deliverables are Windows drivers, and the Windows Driver Kit is what turns them into drivers. A reader expecting a clone-and-run line will not find one, and a reader who only has a Linux toolchain finds no alternative path documented anywhere in the repository. There are no GitHub releases either, so there is no prebuilt driver to download as a fallback. Every part has to be compiled from its own directory on a machine where the driver kit is installed. Nothing in the repository documents a signing step, a signing certificate, or how to load the finished driver, so the distance between compiling a part and running it is left to the tutorial pages. For a series aimed at people learning VMX operation, VMCS and extended page tables, that is a reasonable trade, but it moves the first stretch of setup work onto the reader: two Microsoft installers before a first build, and no way to shortcut it from the repository.

The series warns readers off its own earlier parts

The Note section is the most opinionated text here and it is aimed squarely at anyone who wants to copy code out of the repository. Hypervisors change over time because operating systems add features and techniques move, and the note uses the Meltdown and Spectre fixes as the example of work that forced changes across hypervisor implementations. The project's answer is to push corrections into the newest parts while leaving earlier parts untouched, so part 2 stays as it was written and part 8 carries the accumulated fixes. The consequence is stated outright: earlier parts can produce errors and instability problems, and anything used in real projects should come from the latest parts. The instruction extends to readers who want the series in projects or research, which makes the eight directories uneven by design rather than by accident. That reframes them as a set. The parts in this repository are not eight interchangeable snapshots of one driver but one current path and seven historical ones. The only in-repository signal for which parts have been revised is the directory list plus commit history, and no file states that a given part is stale or current.

Hyper-V nested virtualization starts at part 8

Every driver in the series is tested on two setups: a physical machine, and nested virtualization inside VMware Workstation. The Environment section adds a third and attaches a condition to it. Support for Hyper-V nested virtualization arrives from part 8 onward, so part 8 and later can be tested on a physical machine, inside VMware Workstation and inside Hyper-V, while parts 1 through 7 are documented only for the first two. The split is left unexplained. Whether the earlier parts fail under Hyper-V, run with reduced features, or were simply never retested there is not stated, and the tutorial text lives outside the repository on rayanfam.com, so the per-part pages are where such a difference would have to be resolved. For a reader on a Windows machine whose virtualization comes from Hyper-V rather than VMware, the practical effect is concrete: the first seven parts have no documented test path for their setup, and part 8 is the first one the project's own testing statement covers. Each part's text also lives at its own address under rayanfam.com, from hypervisor-from-scratch-part-1 through part-8, so the environment notes the repository compresses into one paragraph are spread across eight pages the repository does not mirror.

Extended page tables arrive in part 4 and return in part 7

Read the eight part titles as a sequence and the curriculum is visible without opening a source file. Part 1 covers basic concepts and setting up a testing environment, part 2 enters VMX operation, part 3 sets up a first virtual machine, part 4 turns to address translation with the Extended Page Table, part 5 sets up VMCS and runs guest code, part 6 virtualizes an already running system, part 7 returns to EPT for page-level monitoring, and part 8 is titled How To Do Magic With Hypervisor. Extended page tables therefore appear twice, as the subject in part 4 and as an instrument for watching pages in part 7, which is where a reader meets the second use from. Two titles break the mechanical pattern. Part 6 is the pivot of the whole series, because a hypervisor that starts after the operating system is already running is a different problem from part 3's first virtual machine. Part 8 is the only title promising an effect instead of naming a mechanism, and no artifact at the repository root pins down what that effect is. The ordering also fixes a dependency chain rather than eight interchangeable exercises: page tables come after the first virtual machine, VMCS and guest code come after page tables, and page-level monitoring comes last.

An August 2022 revision notice beside a May 2026 commit

Two dates in this repository sit far apart. The notice near the top says the tutorial was completely revised in August 2022, when codes from all parts were updated, unnecessary details were removed and new explanations and materials were added. The last commit on the default branch, master, is dated 2026-05-13. In between the repository carries 2,667 stars, 360 forks and 5 open issues. The gap is worth stating because nothing in the repository bridges it: the notice describes a single 2022 pass across all parts and says nothing about which parts changed afterwards, so a reader who wants the current version of one part has to read commit history instead of a status table. There is no changelog, no maintenance statement and no release train at the root to consult. The licensing side is unambiguous, with an MIT LICENSE file beside the C sources, and the credit block names two authors, Sina Karvandi and Petr Beneš, followed by ten people thanked by name for solving problems in the series. The tutorial pages are the other half of the project, and nothing in the repository connects a commit on master to what a reader sees there.

Where the opening page sends you instead of describing itself

The first paragraph of the README does not describe Hypervisor From Scratch. It recommends HyperDbg, a hypervisor-based debugger built for analyzing, fuzzing and reversing applications, and points to a free course at ost2.fyi/dbg3301 on OpenSecurityTraining2's site, marked as preferred over a YouTube playlist covering the same ground. Further down, readers who want to know more about hypervisors are sent to the awesome-virtualization list. That is the whole of the project's own routing, and it reads as a statement of purpose: source code to read next to the eight tutorials published at rayanfam.com, not a tool to install. It also fixes the audience. Someone who wants a debugger for a suspicious process is sent elsewhere in the first paragraph, while someone who wants to see VMX operation, VMCS and EPT assembled in C is pointed at a part directory and a Windows machine with the driver kit. The thanks list that closes the page names Alex Ionescu, Satoshi Tanda, Liran Alon, Daax and five more people, which is more specific about who helped than most tutorial repositories bother to be.

Editorial conclusion

Read it as a course rather than a dependency: the drivers exist to be read next to the tutorial pages, the repository ships no binary to install, and its own note tells you not to build anything real on the early parts. Before trusting a specific part, check commit history for what changed after the August 2022 revision and whether your setup matches the part you need, since Hyper-V nested virtualization is only covered from part 8. If you want a maintained tool instead of teaching material, HyperDbg is where this project sends readers who need analysis and reverse engineering.

Frequently asked questions

How does Hypervisor From Scratch go about building a hypervisor?

It splits the work into eight parts, each with its own top-level directory: part 2 enters VMX operation, part 3 sets up a first virtual machine, part 5 sets up VMCS and runs guest code, part 6 virtualizes an already running system, and part 7 returns to EPT for page-level monitoring. The drivers are compiled with Visual Studio and the Windows Driver Kit, and from part 8 onward Hyper-V nested virtualization joins the physical machine and VMware Workstation setups.

What does Hypervisor From Scratch actually ship, given that it publishes no releases?

Eight source directories named after the tutorial parts, plus README.md, LICENSE and an images folder. The repository publishes no GitHub releases, so there is no driver package to download: every part has to be compiled locally with Visual Studio and the Windows Driver Kit.

Can the Hypervisor From Scratch drivers be built on Linux?

No Linux path is documented. The Compile & Install section names Visual Studio first and the Windows Driver Kit second, and the parts are described as Windows drivers, so the repository gives no instructions for a Linux toolchain.

Why does the Hypervisor From Scratch page point to HyperDbg and awesome-virtualization?

HyperDbg is described as a hypervisor-based debugger for analyzing, fuzzing and reversing applications, with a free course at ost2.fyi/dbg3301 that the project marks as preferred over a YouTube playlist. awesome-virtualization is offered as the place to read about further hypervisor projects.

Official sources

  1. Issues
  2. License: MIT
  3. Project website
  4. README
  5. SinaKarvandi/Hypervisor-From-Scratch on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/sinakarvandi-hypervisor-from-scratch.svg)](https://hysenlabs.com/projects/sinakarvandi-hypervisor-from-scratch)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/sinakarvandi-hypervisor-from-scratch.svg)](https://hysenlabs.com/projects/sinakarvandi-hypervisor-from-scratch)

Was this useful?