The Linux Unified Kernel Project
-- Linux Unified Kernel 0.2.1
(c) 2006 Insigma Co., Ltd
This is an opensource project; you can redistribute and/or
modify the programs under the terms of the GNU General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
Linux Unified Kernel is a project (linux.insigma.com.cn) in the
Insigma Research Institute, which is a subdivision of Insigma
Co., Ltd (www.insigma.com.cn).
Insigma Co., Ltd (www.insigma.com.cn).
o This package implements the basic mechanisms of Microsoft
Windows includeing process/thread mamangement, object
management, virtual memory managment and synchronization.
With the support of Linux Unified Kernel 0.2.1, most of
general Win32 applications (see APPLIST) can run directly
To Build and Run:
To build Linux Unified Kernel, there are 3 steps to go:
o Build Linux kernel
o Build Linux Unified Kernel module
o Build Wine
To run a Win32 application, you can just input the executable
file in shell or double-click the shortcut.
To get more details of building and running, please read INSTALL.
To Do in Future:
o File System Integration.
o Bug Fix for Pthread TLS.
o Windows Application Testbed.
o The Windows Registry mechanism.
o Various system call functions on the Windows syscall interface.
o The WDM device driver framework.
o The Windows DPC mechanism.
o Exported kernel functions defined by Windows DDK.
The previous release (0.2.0) of the Linux Unified Kernel implemented
Windows Process/Thread creating, so that some simple Win32 programs might
work on Linux. Howerver, many other Windows mechanisms like multi-threading
were not implemented, and most of general Win32 applications can't run with
this release's support.
What's new in this release
Virtual memory management.
Built-in EXE loading function.
Patches for both updated Linux kernel and Wine.
Many bug fixes in process/thread creating.
How it can be used
After installing the Linux Unified Kernel 0.2.1, you can run the programs
directly listed in APPLIST.
This version of Linux Unified Kernel provides several Windows mechanism
implementations, including process/thread management, object management,
virtual memory management, synchronization, etc. Also, the relevant system
calls are implemented to replace the services running in the user space.
Process/thread management which is one of the most important components
in Linux Unified Kernel is implemented based on the previous release. In
this version, some other strategies such as multi-threading are introduced,
so that the process/thread management can take the place of the
corresponding operations in Wine.
Object management and virtual memory management are the new features.
Object management which has no counterpart on Linux builds an
infrastructure for all the Win32 objects, and virtual memory management
combines Win32 system calls to their core operations in Linux kernel.
Synchronization in this version is improved from the previous release, and
the strategies enable the implemented objects to be synchronized when
processes or threads are running.
For compatibility consideration, this version also provides some operations
to work with Wine. For example, the module loading built-in EXEs is offered
to run the "exe.so" programs in Wine, like explorer.exe.so, regedit.exe.so,
etc. You also can run the tools which Wine provides to configure or to do
Not fully implemented
Linux Unified Kernel 0.2.1 provides the mechanism to run built-in EXEs, but
this support is not perfect for some application installations. As a result,
you need run the script switch.sh before installing a Win32 application
(please see INSTALL for details).
This release of Linux Unified Kernel provides some operations like token
-opening which are in the range of security mechanism. These operations will
not work exactly as they do on Windows, but they are needed by the current
Linux Unified Kernel in other mechanisms. Those components will be fixed in
About this list
This version of Linux Unified Kernel implements some most important
mechanisms, and fixes many bugs in the last version. Now many
general Win32 programs can run on Linux system. Here is the list
of some important applications that we have tested.
The applications on the list may not work well as on Windows system.
You can report the bugs to email@example.com.
Microsoft Office 2000 ( Word, Excel, PowerPoint)
Dream Weaver 8
Acrobat Reader 5
To get the support of Linux Unified Kernel, there are 3 basic steps to go:
1. Build Linux kernel
2. Build Linux Unified Kernel module
3. Build Wine
To run Win32 applications on Linux Unified Kernel, just do it like running
a Linux program.
For more details, please read the rest of the file.
The current version (0.2.1) of Linux Unified Kernel provides 2 patches for
both Linux kernel and Wine, so the versions should be specified.
Make sure you have installed the X11 development include files
(called xlib6g-dev in Debian and XFree86-devel in Red Hat).
Build tool requirements:
Make sure you have at least gcc 3.2 available which Linux kernel 2.6.23
Building Linux kernel
To build Linux Unified Kernel, the first thing is to patch the Linux
kernel 2.6.23. First, cd to the top-level directory of the kernel-source
code (linux-2.6.23), then run the following command:
patch -p1 < path/patchfile
where "path" is the path of the patch file and "patchfile" is its file
name (In this package, it is unifiedkernel-0.2.1-k2.6.23.diff in the
After patching kernel, configure it like:
The general configuration file is provided in the patch (you can also
configure it yourself), you can just save and exit to run the next
Then reboot your system to build the Linux Unified Kernel module.
Building Linux Unified Kernel module
To build the module, cd to the "module" directory and run the command:
Then install the module to get the Linux Unified Kernel support:
To use the Win32 programs, you need to build the user space environment.
The script install.sh will help you do this building work automatically:
./install.sh -w wine_path -f patch_file -p prefix
where "wine_path" is the path of the Wine-source code(0.9.40), "patch_file"
is the patch file name of Wine(unifiedkernel-0.2.1-w0.9.40.diff), and
"prefix" is the directory of storing the built-in programs whose default is
After the 3 steps of building, you can run none-installed Win32 programs
that APPLIST lists.
./calc.exe (running Win32 Program calculator in the
/usr/notepad.exe (running Win32 Program Notepad in an
or double-click the icon created either by the install program or by
As this release of Linux Unified Kernel doesn't support build-in EXE
perfectly, so you need to install the Win32 applications like Microsoft
Office 2000 that need installation in the Wine environment.
Everytime you want to install a Win32 program, please follow the 3 steps:
./switch.sh -p prefix -w wine_path -d wine (chang to the Wine
wine setupfile (install application)
./switch.sh -p prefix -w wine_path -d unifiedkernel (chang to the Unified
where "setupfile" is the file name of the installation file like
"setup.exe", and the options "prefix" and "wine_path" represent the same
meanings as they are in the script install.sh.
After that, you can run a Win32 program with the Linux Unified support.
* Note: everytime you want to install a Win32 application, please use the
3-step installation, and after that, it will keeps you running Win32 programs
in Linux Unified Kernel environment.
Linux Unified Kernel is not yet completed, so several programs may crash
or not work exactly as on Microsoft Windows. You can report these bugs to
If you don't want to use Linux Unified Kernel any more, you can uninstall
1. Uninstall module:
cd to the directory "module" and run command:
2. Unpatch Linux kernel 2.6.23 and Wine 0.9.40:
cd to the top-level directory of the kernel-source code or Wine, then run
patch -R -p1 < path/patchfile
where "path" is the path of the patch file and "patchfile" is its file
And then, you can rebuild them.