From ReactOS Wiki
Jump to: navigation, search

Having found the official tutorials sometimes hard to understand and ambiguous, my aim was to make these tutorials simple to understand; I hope that I have achieved that and you find them helpful.

What I have written here is from personal experience; if I cannot do it myself, then I cannot write about it.

A layman's guide - Getting an ISO to test

This should not be needed, but this is a layman's guide, so I will describe where to get your ReactOS iso from.

Release ISO

On the front page at on the right hand side of the navigation bar, you will find two download buttons [No1], click on either button and it will take you to the Download page for the release ISOs, where you have a choice of down loading a bootcd or a livecd, but there is also a link to the daily build ISOs page, further down this page [No2].

Note: If the latest release ISOs, are more then a week old, it is better not use them for testing, because they very quickly become out of date, due to the continual development of ReactOS.

Latest build ISO

On the front page, if you scroll down a little, you will see over on the right side of the page, underneath  and more..., the box shown in image No3a.

If you click on the Daily builds button, it will close the Gallery section and open the Daily builds section [No3b], to reveal the Download here! button. If you then click on the Download here! button, it will take you to the Trunk Builds page [No4].

Trunk Builds page explained [No4]:

Revision - The input box shows the number of the last created ISO. The left and right arrows decrease or increase the number. You can also type a number into the box and press Enter on your keyboard or press the Search button. This is useful when you want to find a ISO from the past. Browse all created Builds button with take you away from this page to, where there are folders for bootcd and livecd ISOs. Bootcd ISOs go back to Mid Jan 2008, newest at the bottom and the oldest at the top. Livecd ISOs currently only go back to April 2017 (this may alter each year).

Image Types - The check boxes here are only useful when you are searching for a particular build from the past. You can uncheck the types you do not want. The Search button updates the list of files.

Debug Boot CDs

  • reactos-bootcd-0.4.7-dev-575-g48b2714-x86-gcc-lin-dbg.7z
  • reactos-bootcd-0.4.7-dev-575-g48b2714-x86-msvc-win-dbg.7z

Debug Live CDs

  • reactos-livecd-0.4.7-dev-575-g48b2714-x86-gcc-lin-dbg.7z
  • reactos-livecd-0.4.7-dev-575-g48b2714-x86-msvc-win-dbg.7z

Release Boot CDs

  • reactos-bootcd-0.4.7-dev-575-g48b2714-x86-gcc-lin-rel.7z

Release Live CDs

  • reactos-livecd-0.4.7-dev-575-g48b2714-x86-gcc-lin-rel.7z

Size and Last changed, are self explanatory.

Note: On the website there are several possibly confusing words, such as Trunk Builds, Daily Builds, Nightly Builds, CDs and on a link button Latest Build!, these all refer to the 7zipped ISO files that can be down-loaded at the page shown in image No4.

A layman's guide - How to compile ReactOS.

In this tutorial there is also a Unix based subsection (this requires updating to git).

Git has now replaced SVN, so this tutorial now describes how to download the source with Git.

You will need to install git for Windows from and TortoiseGit from

Next you will need to create a master folder to keep all the next folders in one place. This folder can be created in C: or D: (or any other drive partition), for example D:\ReactOSDevelopment or C:\ROS.

Create the following folders in your master folder:

1. \source (the name does not matter - you will download the source tree into this folder).

2. \compiled (the name does not matter - this is the output folder where the binaries are complied to and the ISO is created).

3. \RosBE (this is where you will install RosBE).

You should now have something like the following examples.

Example No1





Example No2




Using example No2, within D:\ReactOSDevelopment\ create a compiled folder, a RosBE folder and a source folder. Next, navigate into D:\ReactOSDevelopment\source and right click within the folder, then select Git Clone, then in the next window, enter this url; this will create a reactos folder and download the current source tree into it.

I have noticed this behaviour with Git; if you first copy the url, then click in the source folder, you will find that Git has put the copied url in the Url input and put the path to your source folder with the addition of reactos, in the Directory input. See [1] [2] [3a] [3b] [4] in the Getting the source with Git section below.

For how to update your local source, see the subsection Updating a local source tree with Git.

Having downloaded the source you will now need to download and install the ReactOS Build Environment [5] [6] [7] (a link to the latest version (Windows and Unix) can be found here: into D:\ReactOSDevelopment\RosBE (I select to have a desktop shortcut. See also Note), then start it, and from it's command prompt: [8]

1. Navigate to D:\ReactOSDevelopment\compiled and type D:\ReactOSDevelopment\source\reactos\configure ninja

2. Still within D:\ReactOSDevelopment\compiled type ninja bootcd


3. Still within D:\ReactOSDevelopment\compiled type ninja livecd


4. Still within D:\ReactOSDevelopment\compiled type ninja hybridcd

or if want all three ISO images

5. Still within D:\ReactOSDevelopment\compiled type ninja bootcd livecd hybridcd

Now you should find the bootcd and/or the livecd and/or hybridcd in D:\ReactOSDevelopment\compiled\reactos.

If you have problems compiling after you have updated your local source tree, try typing ninja clean and then start again at step 1 above.

Note: If you did not install RosBE with a desktop shortcut selected, then open a command prompt window and navigate to D:\ReactOSDevelopment\RosBE and type RosBE to start it.

Compiling - Screenshots

Getting the source with Git

The following window will then open.

Updating a local source tree with Git

Configuring and installing RosBE

Configuring and installing RosBE


In the screenshot of RosBE, you can see that the working directory as been changed from source to compiled, then configure ninja as been executed and completed. The command line now shows ninja bootcd waiting to be executed.

How to compile ReactOS - Unix subsection

You will need Git, which should be in your system. To test for Git, type git --help at the command prompt in a terminal window, if it doesn't displayed the help text, then you will have to install it through your package manager.

You will also need to download the ReactOS Build Environment (RosBE), from


Unpack the RosBE installation files to /home/RosBE-Unix-2.1.2 directory.

Create the following folders /home/RosBuild then /home/RosBuild/RosBE (install RosBE in this folder).

Note: The default directory for RosBE, is /usr/local/RosBE, if you prefer, you can use that.

To continue with my example; Open the folder /home/RosBE-Unix-2.1.2 and right click within [9], for the menu, Window - Terminal Here [10].

In the terminal window, run the builder script by typing ./

If it reports any missing tools [11], you will need to install them (the package devx.sfs worked for me).

Then run the script as before, and if it reports all tools OK [12], then you can continue.

To follow my example, type /home/RosBuild/RosBE for the install directory and then follow the instructions from the running script.

If all went well, then it will ask you about creating a shortcut, just follow the instructions.

I created the shortcut in /home then copied it onto the desktop and checked to see if it ran RosBE.

To populate your source folder, you will need to open a terminal window within the empty source folder; right click - Window - Terminal Here, then at the command prompt, type: git clone This will create a folder called reactos and download the main source code.

To get the revision number, right click on the reactos folder and select Window - Terminal Here, then at the command prompt, type: git describe, which will display something like this 0.4.7-dev-532-g3cd76b91b5.

The alternative to the 'Right click-Window-Terminal Here' method, is to type the full address, eg. /home/RosBuild/source.

To update the source code, right click within the reactos folder and select Window - Terminal Here, then at the command prompt type: git pull

NOTE: You must be actually in the source folder to clone and actually in the reactos folder to update the source or get the revision number.


Start RosBE and at the terminal command prompt type cd /home/RosBuild/compiled (or the directory that you want ReactOS to be built into). Then type /home/RosBuild/source/reactos/ When the script finishes, type cd /home/RosBuild/compiled/reactos/ and then ninja livecd or ninja bootcd


A layman's guide - How to get a debug log.

This guide shows you how to, using the built in ReactOS debugger, get a debug log. You will need to install or run one of the debug ISOs in the list below and choose Debug mode at the boot options menu [1]; for other modes see Variations below, but please read this section first.

Debug ISOs



Hardware requirements:

  • A test computer with a serial port.
  • A second computer with a serial port and Putty installed (or similar app).
  • A nullmodem cable to connect both computers.


Win32 Putty - You will also find the source code for Windows and Unix at this link, but Linux users may be able to get Putty through their Package Manager.

Setting up Putty.

There are some vital settings in Putty, which need to be set, so that Putty can capture a debug log. In putty go to Category and select Session, then set the following inputs to these values:
Serial line = COM1
Speed = 115200
Connection type = Serial

Back to Category and select Logging, in Session logging: check All session output. Note where Putty saves the log file and change if required; use the Browse button for the destination folder.

See in Screenshots [2] [3] below for visual information.

Save the above changes in putty, with a name of your choice, in Saved Sessions, then use the Save button. It can then be loaded the next time you use Putty, by using the Load button. Note: logging is started by using the Open button.

The ReactOS debugger

The ReactOS debugger has some commands that can be used from the command line; all of the commands are typed into the ReactOS test computer, but will be viewed in the terminal window (i.e putty) on the second computer. To enter a command, press the hotkey combination of Tab+k, which halts the system and gives you the command prompt which looks like this: kdb:> where you can then enter the command.


Tab+k - this command halts the system so you can enter commands into the debugger.
bt - this command gives a backtrace; use it when ROS enters the debugger (see below).
cont - this is short for continue.
set condition * first always - this command tells ROS to enter the debugger on the first exception.

The following is an example of when ROS enters the debugger (see also in the [4] screenshot below):
Entered debugger on last-chance exception (Exception Code: 0xc0000001) (Unknown/User defined exception)

Getting a backtrace:

By looking in the Putty window, you will see when ROS enters the debugger, when that happens, you need to enter bt at the command prompt, like so: kdb:> bt [4] and press enter on the keyboard. You may see this
--- Press q to abort, any other key to continue --- [5]
If you do see it, then just press any key other than q, it may show again, just repeat until you are back at the command prompt of kdb:>

Getting a more detailed backtrace:

When you see debug info streaming into putty [Note], then press the hotkey combination of Tab+k on your keyboard, then type set condition * first always at the command prompt and press enter on the keyboard, then type cont [6] and press enter on the keyboard. Setting the condition to first always, will make ReactOS enter the debugger on every exception, which it will do many times, and each time you will have to type bt then cont.

Note: If you are testing an app, then it is better to wait until you are ready to run the app, before setting the condition to first always, else you could be overwhelmed with ReactOS entering the debugger.

No working keyboard!

Currently (Jan 2015) usb support is problematic, so your keyboard may not work! If you have found that your usb keyboard does not work with ReactOS, and ReactOS bsods at or before the first input window in the installation process, but after it is running in memory, you should still be able to get a debug log by using a livecd debug version (example: reactos-livecd-0.4.7-dev-575-g48b2714-x86-gcc-lin-rel.7z). The livecd versions currently default to Debug mode, so when it boots, it will output debug info to the serial port, but you will not be able to get a backtrace!


Do not use Tab+k and bt to get a backtrace, when ReactOS does not automatically enter the debugger! If you think by doing so, you will get some more useful information for the dev's to work with (which I have done in the past), you will not, it is a waste of time, the backtrace is of no value!

Putty names the file putty.log, it would be a good idea to re-name it, because the next time that putty is run, it will over-write the file called "putty.log". I use something descriptive, in this format "app name - ReactOS revision number", for example "gimp-1.0.4 [0.4.7-dev-575-g48b2714]".

TIP: If you find that when you use the test computer's keyboard to enter commands, nothing appears at the Command Prompt on the second (receiving) computer, then type the command on the second computer's keyboard, you then should see what you type appear at the Command Prompt.


RosDbg - This is only useful when ReactOS is compiled with a Microsoft compiler, which adds extra debugging code into ReactOS, which can output extra debug info. In use, the difference is in the keyboard input, where you can only use Tab + k on the ReactOS test computer, all other keyboard input is via the logging computer's keyboard.

Screen - In this mode, debug information is written to the screen and you will have to take photos to be able to submit the information in a JIRA Issue. Any keyboard input is done on the ReactOS test computer keyboard. The instructions for Debug mode also apply to Screen mode.

Log file - This writes all debug output to a debug.log at C:\reactos\, on the ReactOS test computer's hard drive. Any keyboard input is done on the ReactOS test computer keyboard. You may, also need to use a Linux livecd to be able to recover the log file from the test computer.

Getting a debug log - Screenshots

Getting a debug log from VirtualBox

This section covers a simple VirtualBox setup using com0com or tty0tty as a virtual null modem cable to connect to Putty; all running on the same computer, no need for a real null modem cable and a second computer.

VirtualBox for Windows, Unix, can be down loaded from (plus installation help, should you need it), it is also available for Unix through your package manager.

Note that for Unix, you will need to have the development package and the kernel source or header files installed.

Install VirtualBox for your operating system, then start it. You will first need to create a virtual machine to install ReactOS into; this is done by clicking on the blue New button. In the first setup window you will need to give it a name in Name:, then set it to Microsoft Windows in Type: and then set it to, either WindowsXP(32bit) or Windows 2003(32 bit) in Version:, then for a simple setup, you can accept all the defaults in all the other setup windows (I alter just one item, I select VHD (Virtual Hard Disk) in the last setup window). There is no need to install ReactOS into the virtual machine just yet, if you want to log the debug output from the start of an installation.

Note: You may find it helpful if you name the virtual machine with a descriptive name, such as 0.4.7-dev-582-g74cc915 or ReactOS-g74cc915 or ROS-0.4.6 (g74cc915 is a revision number and 0.4.6 is a release number), especially if you intend doing some serious debugging and having several virtual machines with different versions of ReactOS installed.

There is another user's wiki here which covers a more detailed setup for VirtualBox.

Windows - com0com

Get the latest com0com from and install it. Then run setup [8a], click on the Add Pair button, which creates a pair of virtual ports, then click on the Apply button. There is no need to tick any of the tick boxes.

In the setup window you will see CNCA0 and CNCB0 which are the newly created virtual ports [8] (If you should ever have the need to add more virtual ports, then the next pair will be CNCA1 and CNCB1). The CNCA0 is used in the Path/Address: in VirtualBox virtual machine serial configuration [10] in this format \\.\CNCA0 and the CNCB0 is used in the Serial line in the Putty serial configuration [11a] just as it is.

The com0com virtual ports process remains until you use the Remove button in the setup app, to remove them.

Unix - tty0tty

You can get tty0tty from (the latest is currently tty0tty-1.2).

Unpack the package tty0tty-1.2tgz to a folder; my OS was able to unpack it to /tty0tty-1.2/, just by clicking on the package.

It requires compiling, so navigate to the directory /tty0tty-1.2/pts (cd /tty0tty-1.2/pts) and open a terminal window (right click - Window - Terminal here). At the command prompt type make and shortly you should have an executable file in the pts folder. Then still within the pts folder/directory, type ./tty0tty at the command prompt to run [8b]. The output could be

(/dev/pts/1) <=> (/dev/pts/2)


(/dev/pts/2) <=> (/dev/pts/3)

it may vary. But whatever the left side is, such as /dev/pts/2 will be entered into the Path/Address: in the VirtualBox virtual machine's serial configuration [10] and whatever the right side is, such as /dev/pts/3 will be entered into the Serial line in the Putty Serial configuration, instead of the default com or tty [11b].

I end the tty0tty virtual ports process, by using the Ctrl - c combination, but I would expect it to terminate when the terminal window is closed.

There is another folder in the directory /tty0tty-1.2/module which also requires compiling. This will, when run, create several pairs of virtual ports, which remain until the OS is re-installed or upgraded. I have not used it or included it within this tutorial.

Testing com0com and tty0tty

To test if it works, configure one instance of putty with CNCA0 in Windows or /dev/pts/2 in Unix and another instance of putty with CNCB0 in Windows or /dev/pts/3 in Unix, then run both Windows Puttys or both Unix Puttys and type into each terminal window. If the input from each terminal window is shown in the other terminal window (what is typed into Putty No1 should display in Putty No2, also what is typed into Putty No2 should be displayed in Putty No1), then you have a working virtual null modem cable.

Now you can run your VirtualBox virtual machine and install ReactOS.

Note: When you run your virtual machine with an installed OS, then make sure that there is no bootable media in any of your external drives (floppy, USB or CD/DVD), else the VirtualBox virtual machine will boot it instead of the installed OS.

Now you can refer back to #The_ReactOS_debugger


A layman's guide - How to create a JIRA Issue for your bug.

From the front page, go to the JIRA page ( by clicking on the JIRA link at the top of the page. If you successfully followed the link you should now be at the Dashboard page of ReactOS JIRA, on the right side of the page [1], you should see a login form (there is also a login link in the top right of the page, which will open another page with a log in form), just use your forum username and password.

Note: If you have only just created an account for the forum, you may find that you cannot log into JIRA, if that as happened to you, you will have to wait a few hours and try again (it takes time for your login details (user name, password) to get to all the places it is needed). If at any time you find that you cannot log in, there is something else that you could try; go to the front page and log out, then log in, go back to the Dashboard page of ReactOS JIRA; now try logging in again.

When you have logged in, the next thing to do, is a search to see if your bug issue has been reported already. Use the Search box at the far right of the navigation bar at the top of the page [1] or on the Issues link on the navigation bar [2].

Click the Search for issues, which will take you to the Search [3] window.

You need to put your search word(s) in the box Contains text and press Enter on your keyboard. The list in the side window will update and the first result will be highlighted and the report will be shown in the main window. You can scroll down the list in the side window, by using the down arrow key on your keyboard; the main window will then update with the report which is highlighted in the side window. If you think a reported issue matches the bug issue you wish to report, then, if you think that you can add further information which could be helpful, then use the Comment button [10] at the bottom of all the Comments, which opens the Comment editor [11]. When you have made your comment, click on the Add at the bottom right of the editor window.

If you did not find anything that could be the same bug as yours, then you will have to create your own bug Issue report.

Don't be intimidated by JIRA, it is very simple to create an issue! You will need to be logged into JIRA and you will see a nice blue Create Issue button to click, at the top of the page on the navigation bar [4], which will open a Create Issue form [5], when the form appears, there are just 2 input boxes to fill in (leave the others alone).

Give a short description of the problem in Summary (this will be the title of the report).

In Description, state if you were testing in real hardware (list your computer specification), or in a virtual machine (state what VM you use), then the revision number of ReactOS that you are using (if the problem involves additional software, then include the down-load link to that software), then describe what happens and how to replicate the problem. Here is a good report to give you some ideas on how to make a helpful report, which will help the developers find and fix the problem.

If you get a debug log or take a photo or video, use the Browse link in Attachment or drag and drop files into the Attachment to upload it.

That is all you need to fill in, leave the rest to the developers. To submit your report, click on the Create button in the bottom right of the form.

Adding more debug logs, photos and videos.

Having created a JIRA Issue for your bug, you have a need to add another debug log, photo or video.

Go to ReatOS JIRA and log in. Then go to the Issues [6] button and select Reported by Me [7] and your Issues will be shown.

Find your report and then scroll down the side window and select the Issue you want to add more files to. Then use either the More tab, then in the drop down list, click the Attach files link [9].

Or further down at Attachments, you can use the Browse link or drag and drop files into Attachments to upload it [9]. In the Comment box you can describe the attached file(s) and any further information about the Issue you wish to add, then use the Attach button at the bottom of the form, to attach it all to the report.

If you only want to add more information, or to reply to a question from a developer, use the Comment button [10] at the bottom left of the page, which will open a Comment form. When you have finished writing in the Comment form, use the Add buttom [11] to attach it to the report.

When you first created your bug issue report, you may have chosen the wrong words for the Summary (the summary becomes the title of the report) and you now want to change them for some that better describe your bug. In the Reported by me Issues window [8], move your mouse pointer over the title and a pencil will appear at the end [12], click on it and a cursor will appear in the title, so that you can edit the it. , When you have finished editing the title, press Enter on your keyboard.

* You are strongly advised to follow the instructions here in the main text and not to go altering things like Priority, Component/s or Fixed Version/s, which are accessible from the Edit button [9]. Please do not upset the developers by altering things that you do not fully understand! You may think that a bug is a Blocker or Critical, but the developers may think that it is only Minor or Trivial.

If you read JIRA Dashboard commits, and see something that you can usefully comment on, then you can make a comment by clicking on Comment at the bottom of the commit, which will open a drop down form [13], where you can make your comments. When you have finished, just click on the Add button.

Note: When adding comments to your own or other peoples reports, ask yourself 'does this add value to the report', 'is it going to be helpful'. Please do not make trivial or silly comments, it is better to click Cancel than to fill JIRA with rubbish comments. So make sure that what you have typed will help others, before you activate the Add button.

A layman's guide - Regression testing: finding the guilty revision.

The ISO files now come in the file format shown below.


To do a search at the getbuilds page ( you only need the portion shown in the last line (above).

Because of the way that Git tracks commits to the source tree, you can no longer use numbers in the same way that you could with SVN. So if you have tried a revision some days ago that was good and did not have the problem, then you can get the reference code (as shown above) from this good revision, then the reference code from the bad revision that exhibits the problem. Using these two numbers, you can then do a search at the getbuilds page (

To do a search, just uncheck all the boxes that are not required, put the two codes in the input box, with a dash between them, like so: 48fe086-74cc915, then click the search button. The search will then list all the revisions between and including the ones typed into the search input box.

You are advised to copy paste the search results into a Text Editor, for further reference, unless you keep the page open with search result in.

If you know that you have tested a good revision in the past, but cannot remember it's revision number, then you can list all the bootcd files at

We will assume that revision 74cc915 has a regression, so it is the ' bad ' revision, you will need to find a ' good ' revision.

Using revision 74cc915 as the bad reference point, using the list of ISO files, go back in increments of 100 or one week, installing and testing them, until you find the ' good ' revision. When you have found a ' good ' revision, that will be the good reference point and the last ' bad ' revision will become the new bad reference point. Now you have two reference points, a known ' bad ' revision and a known ' good ' revision.

The guilty revision must be somewhere in between the two reference (revision) points!

Next choose a revision that is half way between the two revisions, then test that revision to see if it is good, it will then become the new good reference point, but if it is bad, it will then become the new bad reference point. Keep choosing a revision that is half way between the two, until you have found where the revision changes from good to bad; the bad is the guilty revision that regressed!

Remember that the guilty revision is always between the last ' good ' revision and the last ' bad ' revision, until you have reached the point where they are next to each other.

The old SVN ISO files are in this format r75098 and are still available from, but are not now available at the getbuilds page (, because they are no longer being created.

Note that the old revision numbers cannot be used in the search input box at the getbuilds page.

It as been brought to my attention, that Git has some built in functions that do the same as in this guide. So if you have a local source tree, then you may like to read this Warning: only use these git functions on your local source tree, because of what they do to the tree!

A layman's guide - log2lines.

In this tutorial there is also a Unix based subsection.

You have created a Jira Issue for a bug, you are then asked to translate the addresses in the backtrace that are in the debug log.

To do this you will need log2lines, which comes with RosBE, if you haven't already got RosBE, then it can be down-loaded from Sourceforge

Before you down-load RosBE, create some folders on whatever drive you like and call them whatever you like. In my example, I have created a master folder on drive D:, which I have called DebugWork, this will contain all the files and folders.

You will also need to have 7zip installed; Peazip will not work.


D:\DebugWork (this is the master folder, all the other folders and files are stored in this).

D:\DebugWork\RosBE (install RosBE into this folder, but if you already have RosBE elsewhere, you will not need this).

Put the debug log and the iso into the folder D:\DebugWork (in my example they are explorer-0.4.7-dev-557-g57cda5a.log and reactos-bootcd-0.4.7-dev-557-g57cda5a-x86-gcc-lin-dbg.iso).

Using the example from above, you would type this at the RosBE command prompt:

D:\DebugWork\RosBE>log2lines -m -d D:\DebugWork\reactos-bootcd-0.4.7-dev-557-g57cda5a-x86-gcc-lin-dbg.iso <D:\DebugWork\explorer-0.4.7-dev-557-g57cda5a.log> D:\DebugWork\explorer-0.4.7-dev-557-g57cda5a-new.log


D:\DebugWork\RosBE> ................................ The RosBE command prompt (which shows the directory of RosBE).

log2lines -m -d ................................................ The command to start log2lines with two optional run-time commands.

The command -m puts a * at the front of the translated line, and the command -d indicates that it is a directory or iso image.

D:\DebugWork\reactos-bootcd-0.4.7-dev-557-g57cda5a-x86-gcc-lin-dbg.iso ....... The iso's directory path and name.

<D:\DebugWork\explorer-0.4.7-dev-557-g57cda5a.log> ........ The debug log's directory path and name (you must include < at the front and > at the back).

D:\DebugWork\explorer-0.4.7-dev-557-g57cda5a-new.log ... The directory where the new translated log will be written, with it's name.

If you have RosBE already installed elsewhere, then, using the same folder and files as in the example above, you would just start RosBE and at the command prompt, type: log2lines -m -d D:\DebugWork\reactos-bootcd-0.4.7-dev-557-g57cda5a-x86-gcc-lin-dbg.iso <D:\DebugWork\explorer-0.4.7-dev-557-g57cda5a.log> D:\DebugWork\explorer-0.4.7-dev-557-g57cda5a-new.log

log2lines - Screenshots

log2lines - Unix subsection

To be able to use log2lines in the Unix version of RosBE, you will have to compile the source code first, then you will find log2lines in the /reactos/host-tools/ folder. To use my example, it will be in /home/RosBuild/compiled/reactos/host-tools/.

See the Layman's guide - How to compile ReactOS - Unix subsection, for instructions on how to install RosBE-Unix.

The log2lines command is in this format: log2lines options ISO <old log> new log


log2lines ........ Executes log2lines.

options .......... Optional run-time commands for log2lines. -m Marks the translated line with an * and -d is for directory.

ISO .................. This is the name and location of the ISO image that you used.

<old log> ........ This is the location and name of the original debug log.

new log .......... This is the location and name for the modified debug log. It will be written with that name and at that location.

See also the explanation in the main section above.

For the following example, there will be two extra folders in the /home/RosBuild directory, one called debug-logs, where the debug logs are kept and the other called ISO-images, where the ISO image files are kept. The debug log that will be run through log2lines, is called SteamError2.log.


Start RosBE and at the command prompt, type:

/home/RosBuild/compiled/reactos/host-tools/log2lines -m -d /home/RosBuild/ISO-images/bootcd-75458-dbg.iso </home/RosBuild/debug-logs/SteamError2.log> /home/RosBuild/debug-logs/SteamError2-new.log

NOTE: For log2lines to work, you must give the full path to the host-tools directory. If you get any error message, for example log2lines: command not found, then check that your paths are all correct.

A layman's guide - Miscellaneouse.


Use the following scrips at your own discretion. As with other software, the scripts come with no guarantee!

Windows - Create the Tutorial working environment

This script is intended to be used once, to automate (but needs user input) the setting up of a working environment (all the directory folders, software and ReactOS source code) as described in the Layman's guides. But could also be a useful peice of software to test in ReactOS.

What will this script do?

It first ask the user for a drive letter, then it will use that drive letter to create the following directory structure:


It then down loads a none zipped, none installable version of wget, then down loads 7-zip, curl, Git for Windows and RosBE. All these software down loads must be saved into the Required_Software directory/folder. After each down load, it will start the software's installer, as required.

Next it will down load and clone into the source directory/folder, then it creates a script Revision.txt, which stores the date and revision number. Then it creates another script update-source.cmd, which can be used to update the local source tree, when required (it will update Revision.txt and also create/update update.txt with commit history). These scripts will be found in the REACTOS_DEVELOPMENT directory folder.

Note: The drive letter that was selected in the running script, will also be in the script update-source.cmd!

This is the script (below), which has intentionally been reduced in size to fit the page!

::      This script automates the setting up of a working environment, as per the Layman's guides.     ::
:: I hate EULAs.  ©Nobody.  Use at your own risk! It worked for me and did what it was intended to do. ::
::      It is not the most elegant script and it maybe is over-kill in parts, but it works for me.     ::
@echo off
:: Populate the variable, ready for use.
set text= * An error occured down loading
:: Put the URLs into variables, this will save line length later. 
set Wget=
set zip=
set Curl=
set GetGit=
set RBE=
cd C:\
echo  ##############################################################################
echo  # This script will setup a working environment similar to what is described  #
echo  # in the Layman's guides at (Windows XP or ReactOS) #
echo  #                      Should only need to be run once!                      #
echo  ##############################################################################
echo  Now starting the setup!
echo  Choose which drive to create the directory tree in!
echo  Such as C, D, E, F, etc.
set /p drv= Enter drive letter 
:: Now check to see if the selected drive exists!
if not exist %drv%:\ (echo  * Drive %drv%: does not exist! && goto :choice)
echo  The directory tree will now be created in drive %drv%:
:: Now make the directory tree. If the directory does not exist, then create it.
if not exist %drv%:\ReactOS_Development  (mkdir %drv%:\ReactOS_Development && echo  * Created %drv%:\ReactOS_Development)
if not exist %drv%:\ReactOS_Development\Compiled  (mkdir %drv%:\ReactOS_Development\Compiled && echo  * Created \Compiled)
if not exist %drv%:\ReactOS_Development\Debug  (mkdir %drv%:\ReactOS_Development\Debug && echo  * Created \Debug)
if not exist %drv%:\ReactOS_Development\ISO  (mkdir %drv%:\ReactOS_Development\ISO && echo  * Created \ISO)
if not exist %drv%:\ReactOS_Development\Required_Software  (mkdir %drv%:\ReactOS_Development\Required_Software && echo  * Created \Required_Software)
if not exist %drv%:\ReactOS_Development\RosBE  (mkdir %drv%:\ReactOS_Development\RosBE && echo  * Created \RosBE)
if not exist %drv%:\ReactOS_Development\Source  (mkdir %drv%:\ReactOS_Development\Source && echo  * Created \Source)
:: Move into the software directory to down load the required software.
cd %drv%:\ReactOS_Development\Required_Software
echo  ################## PLEASE READ THE FOLLOWING ##################
echo  wget will be down loaded next, either with dwnl (ReactOS app) 
echo  or with your default browser!
echo  Please make sure that your browser saves it to
echo                  %drv%:\ReactOS_Development\Required_Software.
:: Pause here to give time for the above text to be read.
set /p temp="Please note the above and when you are ready, press Enter to continue"
if not exist wget.exe (echo  ... Down loading wget! && dwnl %Wget% wget.exe || echo Your browser will now open! && start %Wget% || goto :errorwget) else (echo  * You already have wget.exe && goto :get7-zip)
set /p temp="When wget has been saved to \Required_Software, press Enter to continue"
if exist "C:\Program Files\7-Zip\7z.exe" (echo  * You have 7zip installed && goto :getcurl)
if not exist 7z1604.exe (dwnl %zip% 7z1604.exe || wget %zip% > 7z1604.exe || goto :error7-zip)
set /p temp="When 7zip has been saved to \Required_Software, press Enter to continue"
if exist 7z1604.exe (echo  * 7zip has been successfully down loaded! && goto :inst7-zip)
if not exist "C:\Program Files\7-Zip\7z.exe" (echo  ... Running 7-zip installer && start 7z1604.exe && ping -n 11>nul)
if exist "C:\Program Files\7-Zip\7z.exe" (echo  * 7-zip is now installed! && goto :getcurl)
if exist curl.exe (echo  * You already have curl && goto :getgit)
if not exist curl_7_53_1_openssl_nghttp2_x86.7z (echo  ... Down loading curl. && wget --no-check-certificate %Curl% || goto :errorcurl)
set /p temp="When curl has been saved to \Required_Software, press Enter to continue"
if exist curl_7_53_1_openssl_nghttp2_x86.7z (echo  * curl has been successfully down loaded! && goto :extractcurl)
if exist curl_7_53_1_openssl_nghttp2_x86.7z (start C:\"Program Files"\7-Zip\7z.exe e curl_7_53_1_openssl_nghttp2_x86.7z && ping -n 11>nul)
if exist curl.exe (echo  * curl is now ready to use!)
if not exist C:\"Program Files"\Git\bin\git.exe (echo  ... Down loading Git && curl --cookie nada --location %GetGit% > Git-2.10.0-32-bit.exe || goto :errorgit) else (echo  * git is already installed! && goto :getRosBE)
set /p temp="When git has been saved to \Required_Software, press Enter to continue"
if exist Git-2.10.0-32-bit.exe (echo  * Git has been successfully down loaded! && goto :instgit)
echo  #################### PLEASE READ THE FOLLOWING ####################
echo ** DO NOT select * mintty * in the installation.
echo  Please select * Windows' default consel window * in the installation.
set /p temp="Please note the above and when you are ready, press Enter to continue"
if exist Git-2.10.0-32-bit.exe (echo  ... Starting the Git installer. && start Git-2.10.0-32-bit.exe || echo  * Failed to install git!)
set /p temp="When git has been installed, press Enter to continue"
if exist C:\"Program Files"\Git\bin\git.exe (echo  *  git has been successfully installed)
if not exist RosBE-2.1.6.exe (echo  * Down loading RosBE && curl --cookie nada --location %RBE% > RosBE-2.1.6.exe || goto :errorRosBE) else (echo  * Found RosBE-2.1.6 installer, so it should be installed! && goto :clone)
set /p temp="When RosBE has been saved to \Required_Software, press Enter to continue"
if exist RosBE-2.1.6.exe (echo  * RosBE has been successfully down loaded!) 
echo  #################### PLEASE READ THE FOLLOWING ####################
echo  The RosBE installer will give you the choice where to install it to.
echo  You can install it to it's default directory or here in 
echo  %drv%:\ReactOS_Development\RosBE or where ever you choose.
:: Pause here to give time for the above text to be read.
set /p temp="Please note the above and when you are ready, press Enter to continue"
if exist RosBE-2.1.6.exe (start RosBE-2.1.6.exe || echo  * Failed to install RosBE!) 
set /p temp="When RosBE has been installed, press Enter to continue"
if exist %drv%:\ReactOS_Development\Source\reactos goto :make_script
cd %drv%:\ReactOS_Development\Source\
echo ... Cloning the ReactOS source tree to a local folder. && git clone || goto :giterror
set /p temp="When the source tree has been cloned, press Enter to continue"
cd %drv%:\ReactOS_Development\Source\reactos
echo ~~~~~ %time% - %date% ~~~~~ 1>>  %drv%:\ReactOS_Development\Revision.txt
:: Find the revision number and write it to revision.txt.
git describe 1>> %drv%:\ReactOS_Development\Revision.txt
:: Check here to see if the script 'update-source.cmd' has already been created.
if exist %drv%:\ReactOS_Development\update-source.cmd (goto :finish)
echo :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: 1>> %drv%:\ReactOS_Development\update-source.cmd
echo :: Automates the updating of your local source tree as per the tutorial.                          :: 1>> %drv%:\ReactOS_Development\update-source.cmd
echo :: I hate EULAs.  ©Nobody. Use at your own risk! It worked for me and did what I wanted it to do. :: 1>> %drv%:\ReactOS_Development\update-source.cmd
echo :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: 1>> %drv%:\ReactOS_Development\update-source.cmd
echo @echo off 1>> %drv%:\ReactOS_Development\update-source.cmd
echo cls 1>> %drv%:\ReactOS_Development\update-source.cmd
echo echo  * Checking for source code changes and additions! Please give it time to complete. 1>> %drv%:\ReactOS_Development\update-source.cmd
echo cd %drv%:\ReactOS_Development\Source\reactos 1>> %drv%:\ReactOS_Development\update-source.cmd
echo git  pull origin 1^>^> %drv%:\ReactOS_Development\update.txt 1>> %drv%:\ReactOS_Development\update-source.cmd
echo echo ~~~~~ %%time%% - %%date%% ~~~~~ 1^>^>  %drv%:\ReactOS_Development\Revision.txt 1>> %drv%:\ReactOS_Development\update-source.cmd
echo echo ~~~~~ %%time%% - %%date%% ~~~~~ 1^>^> C:\ReactOS_Development\update.txt 1>> %drv%:\ReactOS_Development\update-source.cmd 
echo :: Find the revision number and write it to Revision.txt. 1>> %drv%:\ReactOS_Development\update-source.cmd
echo git describe 1^>^> %drv%:\ReactOS_Development\Revision.txt 1>> %drv%:\ReactOS_Development\update-source.cmd
echo  #################### PLEASE READ THE FOLLOWING ####################
echo The working environment should now be all setup and ready to use.
echo A batch script 'update-source.cmd' has been created in %drv%:\ReactOS_Development. 
echo Use this script to update the source tree.
echo .
echo             ~~~~~~~~~~~~~~ Finished. ~~~~~~~~~~~~~~
set /p temp="  Press Enter to exit"	
echo  %text% wget. && goto :failed
echo  %text%  7-zip. && goto :failed
echo  %text%  curl. && goto :failed
echo  %text%  git. && goto :failed
echo  %text% RosBE. && goto :failed
:: This was added because the system did not find git the first time. 
echo  * An error occured while trying to clone the ReactOS source tree!
echo  ######################### PLEASE READ THE FOLLOWING #########################
echo  NOTE: If this script is run again from the begining, it will first check
echo  for the needed software, before attempting any more down loads or installs!
echo  So you could run the script at a another time to clone the source.
set /p yes-no= Do you want to retry to clone the ReactOS source now [y/n]?
if %yes-no%==y echo  * Running the clone section again && goto :clone
if %yes-no%==n echo * You can still try again later. && goto :failed
echo .
echo    *********** Unforutatley, the script as failed to complete! ***********
set /p temp="  Press Enter to exit"

To get the script, just copy from here and paste it into a good text editor (not Windows Notepad.exe), then save it with the file extention of cmd and run it at your leisure. It will save you a lot of typing (if you are happy with the directory names) and it only needs to be run once to create a working environment.

UNIX - Update the local source

This script automates the updating of your local source tree using the directory structure shown in the tutorial. When the update is complete, it will create a file /home/RosBuild/revision.txt with the date and revision number. To use it, copy and paste it into a text editor, change the paths to suit your own directory tree and the file names to your own choice, then save as a .sh file with a name of your choice. You will need to make this script executable by typing chmod +x (path) script name at the command prompt in a terminal window.

# Automates the updating of your local source tree as per the tutorial.
# Run git from the reactos folder.
cd /home/RosBuild/source/reactos/
# Do an update and write the output info to update.txt.
git pull origin 1>> /home/RosBuild/update.txt
# Write the current date to the update.txt.
echo "Update completed ------------ $RevDate" 1>> /home/RosBuild/update.txt
echo "update completed"
# Write the current date to the revision.txt.
echo "$RevDate" 1>> /home/RosBuild/revision.txt
# Get the current revision info and write it to revision.txt.
# The info will be in this format 0.4.8-dev-51-gbe1155f294
git describe 1>> /home/RosBuild/revision.txt
# Draw a line underneath to separate the revision updates.
echo "~~~~~~~~~~~~~~~~~~~~~~~~~" 1>> /home/RosBuild/revision.txt
echo 'done'

Revised and updated March 2017.

Minor text additions and the addition of some Unix subsections - August 2017.

Added debugging with VirtualBox through a virtual serial line (Windows and Unix) September 2017.

Updated for Git, where necessary. October 2017.

Added a new section with some scripts. January 2018.


More tutorials can be found at: