Nano-X Frequently Asked Questions

2010/01/24 Nano-X FAQ - greg [at]

What is the difference between Microwindows and the Nano-X Window System?

There is no difference.  In January 2005, the project changed its name from Microwindows to the Nano-X Window System.  This is a result of conflicts with Microsoft's registered trademark, Windows.

What is The Nano-X Window System?

The Nano-X Window System is an Open Source project that brings some of the features of modern graphical windowing systems to the programming community not wanting or requiring the large disk and ram requirements of higher-end windowing systems like Microsoft Windows or the X Window System.  Nano-X does not require any operating system or other graphics system support, as it writes directly to the display hardware, although it runs well on Linux framebuffer systems.  Nano-X is designed to be portable, and can run in a wide variety of hardware and software environments.  One the of more interesting targets is the emerging market of portable handheld and pocket PC's running Linux, also known as LinuxCE.

What does Nano-X run on?

Nano-X currently runs on 32-bit Linux systems with kernel framebuffer support, under the X Window system, or through the popular SVGAlib library.  In addition, it has been ported to 16-bit Linux ELKS, real-mode and protected mode MSDOS, and the RTEMS real time operating system.  Screen drivers for 1, 2, 4, 8, 16, 24 and 32 bits-per-pixel have been written, as well as a VGA 16 color 4 planes driver.  The Nano-X system has been ported to a number of Handheld and Pocket PC's, as well.  The graphics engine is capable of running on any system that supports readpixel, writepixel, drawhorzline and drawvertline, and setpalette.  Blitting support is optional, but if implemented allows enhanced functionality.  All bitmap, font, cursor and color support is implemented on top of these routines.  Support for 8, 15, 16, 24 and 32 bit truecolor systems as well as 1, 2, 4 and 8bpp palletized systems is implemented.

An X11 driver was completed that allows Nano-X applications to be run on top of the X Window desktop.  This driver emulates all of Nano-X's truecolor and palette modes so that an application can be previewed using the target system's display characteristics directly on the desktop display, regardless of the desktop display characteristics.  This allows Nano-X graphical applications to be built and tested on the desktop without having to cross-compile for the target, with complete emulation of the target's display.  If the desktop is running Linux as well as the target, then the entire application can typically be tested, as the POSIX api is available on both systems.

What CPU's are supported?

The Nano-X Window System is extremely portable, and completely written in C, although some routines have been recoded in assembly for speed.  It has been ported to the Intel 16 and 32 bit cpu's, as well as MIPS R4000 (NEC Vr41xx) StrongARM and PowerPC chips found on popular handheld and pocket PC's.  There have been rumors of an SH3 port as well.

How big is Nano-X?

On 16 bit systems, the entire system, including screen, mouse and keyboard drivers runs in less than 64k.  On 32-bit systems, support includes proportional fonts and applications are typically less than 100k.

What is Nano-X's architecture and what API's are supported?

The Nano-X Window System is essentially a layered design that allows different layers to be used or rewritten to suit the needs of the implementation.  At the lowest level, screen, mouse/touchpad and keyboard drivers provide access to the actual display and other user-input hardware.  At the mid level, a portable graphics engine is implemented, providing support for line draws, area fills, polygons, clipping and color models.  At the upper level, various API's are implemented providing access to the graphics applications programmer.  These APIs may or may not provide desktop and/or window look and feel.  Currently, Nano-X supports the Win32 and Nano-X APIs.  These APIs provide close compatibility with the Win32 and X Window systems, allowing programs to be ported from other systems easily.

What's the difference between Nano-X and NanoGUI?

Nano-X's origin is with NanoGUI.  NanoGUI was created by Alex Holden by taking David Bell's mini-X server and Alan Cox's modifications and adding client/server networking.  Greg Haerr then took interest in the NanoGUI project and began making extensive enhancements and modifications to NanoGUI.  Around version 0.5, Greg Haerr added support for multiple API's, and began distributing Microwindows.  In Microwindows 0.84, all previous NanoGUI changes were incorporated and since then has been the combined NanoGUI/Microwindows distribution.  In January 2005, the system changed its name to the Nano-X Window System, with a planned first release as v0.91.

What's the difference between Win32 and Nano-X APIs?

Win32, Microwindows and Nano-X both refer to programs available within the Nano-X Window System. The system supports two APIs, a Win32 compatible API, and an Xlib-like API, known as Nano-X. The Nano-X is used more commonly than the Win32 API under Linux, since Nano-X supports multiple "client" programs accessing a shared graphics server.

What is the Nano-X API?

Nano-X is the Xlib-like API that the Nano-X Window System supports.  It is based on David Bell's mini-X server API, and includes X-like primitives for low-level window and graphics operations.  Window management is not included, and the window look and feel must be created through a widget set or directly by the applications programmer.  Currently, there are a number of people working on widget sets for Nano-X.  There is some discussion about converting the Nano-X API to be X Window System compatible.

What is the Microwindows API?

The Microwindows API is now known as the Win32 API.  The system supports an API based on the Win32 graphics device interface module, and implements a large portion of it. The function calls try to be 100% compatible, so that code compiled for other operating systems can usually be compiled with no source code changes.  In addition, a portion of the Win32 USER module is implemented, which contains routines for window dragging, title bars,  message passing, and generating required window messages.  Because of this, window manager support is built into the system, and a single API for applications programs can be used that doesn't change based on the widget set being used.

Since the WinCE API is mostly a subset of the Win32 API for graphics-related functions, the Win32 API is also WinCE compatible, and can be used to implement WinCE graphics functions on platforms Nano-X is running on.

What are Nano-X's graphics features?

Nano-X features full RGB color support, color mapping, optimized palette bitmap drawing, truecolor and palletized displays, and a 3d look-and-feel. Overlapped and child windows are supported, with complete window and client area clipping. Proportional and fixed fonts are supported, along with utilities for converting fonts or bitmap files. Optimized painting algorithms are used to allow maximum response while the user is moving windows on the screen.  Offscreen drawing and bit-blit routines are implemented for flicker-free drawing and animation. Polygon draws, fills and arbitrary region clipping are also supported.

What license is the Nano-X Window System under?

The project is licensed under the MPL.  Alternatively, the software can be licensed under the GPL, if desired.  This means that the standard Nano-X distribution can be used for commercial purposes, and supports the needs of developers working under non-disclosure or writing proprietary device drivers.  Modifications to source code supplied in the standard distribution must stay open source.  Or the entire project can be converted to GPL, with files added by a developer considered GPL only.

Where is the most current source?

The FTP site is the primary distribution point for all releases.  The home web site is at  I can be reached at greg [at]  There is also a Git source code repository available, along with current snapshot tarballs:

Anonymous read-only access to git repository:

git clone git://
git clone git://

For intended read-write access to git repository: (previous permission required)

git clone
git clone

For those of you not running git, various tarballs are available via FTP:

Source snapshot (microwindows-src-snapshot.tar.gz)
Fonts snapshot (microwindows-fonts-snapshot.tar.gz)
Full snapshot (microwindows-full-snapshot.tar.gz)
NXLIB snapshot (nxlib-src-snapshot.tar.gz)

Are there screenshots and/or demos available?

There are demos for Linux, ELKS and MSDOS, as well as screenshots, available at: 

Is there a mailing list?

The mailing list is  A web-based signup is available at

To subscribe, send an empty email to:
To unsubscribe, send an empty email to:

Can I search the mailing list archives?

Yes you can search through the Nano-X mail list archives. When you make a search add the text "NANOGUI" to filter out other projects hosted on the Linux Hacker server. 

I can't setup my framebuffer.  Where do I go for help?

There's a framebuffer HOWTO at which should help.  In addition, a very useful framebuffer site for developers is

The nano-X server gives me an error "Cannot bind to named socket". Why?

One thing that will cause this error error is the inability to create (or delete) the named socket "/tmp/.nano-X". You may have problems with this if one user creates the socket and then nano-X subsequently crashes if you try to run nano-X from another userid you will get this error. 
Delete the named socket "/tmp/.nano-X" if it exists, otherwise verify that the userid that is attempting to run nano-X has write permissions to the /tmp directory. 

What's the difference between SCANKBD and TTYKBD in the config file?

SCANKBD is used to link a keyboard driver that knows the difference between keyup and keydown events, as well as all function and other keys, and reports them separately. This allows complete control of the keyboard, for use in games, etc. TTYKBD uses a very simple ascii-only return values, and won't return function key values correctly.

How do I setup the mouse or touch panel?

The mouse type is setup in the Nano-X configuration file, src/config. The mouse type to be used with Nano-X is set in the config file and the specified mouse driver is then compiled in. Touch panel drivers use the mouse interface with a specific driver. Following are the currently supported mouse types settable in the config file:

GPMMOUSE - use gpm to get mouse input (drivers/mou_gpm.c)
SERMOUSE - the the serial port for mouse input (drivers/mou_ser.c)
TPMOUSE - touch panel driver for Linux-VR compatible kernels and VTech Helio (/dev/tpanel, char special 10,11)
ADSMOUSE - touch panel driver for ADS graphics client (/dev/ts, char special 190,34)
IPAQMOUSE - touch panel driver for iPAQ/Assabet (/dev/h3600_ts, char special 11,0)
NOMOUSE - no mouse/touch panel in system

What's the difference between GPMMOUSE and SERMOUSE in the config file?

GPMMOUSE uses the gpm program to get mouse events, SERMOUSE uses the serial port or ps/2 port to get events, and decodes them internal to the mouse driver, drivers/mou_ser.c. If you run GPM, you must use the -R parameter: 'gpm -R -t ps2'

What can I do to help?

We need help in all sorts of areas.  There are currently projects to port base level widget sets and custom controls to Nano-X.  Fast screen drivers and blitting routines are also on the list.  There are lots of folks interested in getting the system to run on one of the many new Handheld or Pocket PC's.  Please join the list and join the fun.