# Microwindows: an X11-shaped windowing system for tiny machines > Microwindows, also called Nano-X, is a small windowing system written in C that implements both the Win32 and the X11-like Nano-X APIs on top of a portable graphics engine, and it targets everything from Linux and macOS down to ELKS, DOS, RTEMS and a handheld console. The NX11 compatibility library lets existing X11 applications link and run without being recompiled. **ghaerr/microwindows** — The Nano-X Window System - Repository: https://github.com/ghaerr/microwindows - Stars: 863 · Forks: 113 - Language: C - License: NOASSERTION - Published: 2026-10-20 · Updated: 2026-10-20 · Language: en - Canonical page: https://hysenlabs.com/projects/ghaerr-microwindows ## Two APIs over one small engine Microwindows, or Nano-X, is described as a small graphical windowing system that implements both the Win32 and the Nano-X, which is X11-like, APIs for clipped graphics drawing in windows, on Linux, Mac OS X, ELKS, EMSCRIPTEN, Android and other platforms. It is open source and the README states it is licensed under the Mozilla Public License. The two API layers are the interesting part. An application written against Win32 calls the functions it would call on Windows, and an application written against Nano-X calls the X11-shaped functions, and neither knows that the implementation underneath is a single small engine rather than the real thing. For the Win32 side the package also includes the builtin Win32 controls, and for the Nano-X side it includes TinyWidget's controls. For building user interfaces the project also offers the Nuklear immediate mode GUI, and the README states that FLTK can be used with the X11 compatibility library, NX11. The README carries an odd note about its own diagram. The architecture picture is introduced as a slightly outdated overview of the system, which is a candid way of saying that the picture is older than the code and the prose below it is the accurate description. The repository itself is small at the top level: .gitignore, LICENSE, a README, a Readme.md, doc/, screenshots/ and src/. Two README files with different capitalisation in the same directory is the kind of thing that trips a case-insensitive checkout, and it is a small detail that suggests the project has been around a long time without much tidying. The last push was on 2026-10-13, the repository is not archived, and there are no GitHub releases. ## Drivers, graphics engine, APIs The library design section describes three layers, and the layering is what makes the portability claim credible. At the lowest level are the drivers for screen output and for mouse and keyboard input, with touch input devices also supported. The README lists the drivers available for X11, frame buffer, SDL, the Allegro graphics library, and VESA or the SVGA library, and says additional drivers can be added to port the system to more platforms. The separate screen driver list in the platforms section adds memory-mapped framebuffer, SDL 2, Allegro 5, Windows, VGA and an X11-based framebuffer emulator. At the mid level sits a portable graphics engine providing line draws, area fills, polygons and clipping, with support for 1, 2, 4, 8, 15, 16, 24 and 32 bit colour models. That colour model list is the giveaway about the target hardware, because the 1, 2 and 4 bit modes exist for monochrome and small LCD displays, and the 15 bit mode is for packed RGB on embedded panels that cannot do 24 bit. At the upper level the Nano-X and NX11 APIs and the Win32 APIs are implemented, giving an applications programmer access to the engine. The last structural decision is how the pieces are deployed. The Nano-X Window System can be compiled either as a separate server for several clients, or linked together into a single, standalone library. That choice is what lets the same codebase serve a multi-application embedded device and a single-application appliance, and it is also why the Win32 and Nano-X layers are described as separately configurable layers on top of one core. ## NX11 is what makes old binaries work The compatibility library is the most valuable idea in the project, and it deserves its own section because it changes what is possible. To provide close X11 compatibility, the NX11 library can be built on top of the Nano-X API, which allows X11 applications to be linked and run without recompilation. The FLTK GUI toolkit runs based on NX11. That is a different proposition from porting an application. Porting means you have the source and you change it, and you keep doing that across the platforms you support. Linking against NX11 means you have a binary and it still runs, which is the only option for a lot of closed and licensed software, and for anything that was built years ago against an X11 that no longer exists on the target. The README extends the same idea twice more. It lists providing Xlib support for platforms without Xlib, and it lists running X11 or Win32 applications in a browser using EMSCRIPTEN, which is the same trick applied to a different target. The FLTK relationship is worth understanding in this context, because FLTK appears three times in the README. It is a GUI toolkit that runs on NX11, it is one of the three toolkits named for providing an excellent GUI for small embedded devices along with TinyWidgets and Win32, and there is a bullet about porting the FLTK GUI toolkit to small platforms. A toolkit that is already small enough to port is the missing half of the compatibility story, and the fact that both halves are here is what makes the project useful rather than merely interesting. ## The platform list is the argument for the project The platforms Microwindows supports are the clearest statement of what the project is for. The list is Linux, Mac OS X, Android, ELKS, EMSCRIPTEN, Nuklear GUI, Windows, Raspberry Pi, DOS DJGPP, RTEMS, ECOS, Sony PSP, Atari Jaguar, Nintendo DS, and more. Read down that list and you can see the shape of the target: an operating system for small embedded Linux, a DOS compiler, two real-time operating systems, a Raspberry Pi, a web build, two handheld consoles and a 64-bit game console from 1994. Cross-compiler toolchains are supported on x86, x86_64, ARM, M68K, PowerPC and MIPS, big- and little-endian, and other processors. The M68K and PowerPC entries are the interesting ones, because they correspond to the older embedded and console hardware in that platform list, and the little-endian requirement covers the 68k and MIPS targets that run byte-swapped. Other entries in the areas list show what the system is for in practice. Linking an application with Microwindows can provide it with a GUI on console-based Linux distros, which is the most common real deployment. Run FLTK or Win32 applications on Android phones. Portrait mode, a rotated mode and auto-flipping are supported for handheld devices, which is a feature you only need on a device with a screen you can rotate. Provide an excellent GUI for small embedded devices with FLTK, TinyWidgets or Win32. And there is the historical entry: the original classic shareware Doom v1.10 ported to Nano-X, with a screenshot of it in the gallery. A software title from 1996 running on a windowing system built for 2026 platforms is the clearest illustration of why the NX11 layer matters. ## What the NEW lines tell you about the current work The areas list is organised with NEW markers on the recent items, and reading them is a way of seeing where the maintainer has been spending time. Nano-X now runs on ELKS, which is the embedded operating system the project has an ongoing relationship with, and the README links it. The Microui immediate-mode UI library has been ported to Nano-X, which adds a second immediate-mode option next to Nuklear and is a way of reaching a UI without writing widgets. PDF viewer and MP4 media player support on Nano-X comes through the FBPDF and FBFF projects, which are separate efforts the README credits, and it means the system can show documents and video without a full desktop underneath it. The updated Nano-X window frame drawing code now resembles the Nuklear UI, and Nuklear immediate-mode GUI apps are now supported in separate windows, so a Nuklear application is a real window on the Nano-X desktop rather than a full-screen takeover. The change in the frame style is a visual one, and it is the kind of change that makes a system look like a coherent desktop rather than a set of unrelated windows. The item with the widest scope is the ability to run multiple simultaneous Win32 apps on Linux, OS X and in a browser, which is the server mode of the design finally working as intended on the mainstream platforms. The remaining NEW items are the PDF and media support, the Microui port, the frame drawing and the multi-application support, and the older entries below them, the Doom port, the browser build, the FLTK port and the Android support, describe what has already been achieved. ## Building it, and who maintains it The install section is short and points elsewhere. To build Microwindows, see microwindows/src/README plus the faq files in the doc directory. For Android there is an application note in the doc directory, and the Atari Jaguar requires a specific treatment. An HTML based FAQ and Architecture document are available from the web site, which is microwindows.org. So the build documentation is in three places: the README in the source tree, the question files in the doc directory, and the FAQ and architecture pages on the site. That is a documentation structure from a project with a long history, where the answers have accumulated in forum-style question and answer files rather than in a single manual. The gallery in the README shows what the system looks like in use, with screenshots of the AGG demo under Nano-X, a Nuklear application, the nxstart desktop, the Emscripten build in a browser, FLTK running through NXlib, Doom, and a pre-release demo on the Atari Jaguar. The maintainer is named in the README: Greg Haerr, with an email address, and the project is maintained under his name. Issues are discussed in Discussions or by opening an Issue, and there is a Discord-style community route through the discussion tab rather than a separate chat. On the terms, the README says the Mozilla Public License and the repository carries a LICENSE file, while the repository's own licence metadata records a custom classification that GitHub cannot identify, which is the same pattern you see when a licence file exists but its text is not recognised. The project is old enough that the file format may predate the classifiers. The LICENSE file is the reference, and for a codebase this old and this widely reused, the terms in that file are the thing to check before you vendor it. ## Conclusion Adopt Microwindows when you are writing a GUI for a machine with no window system at all, or when you have an existing X11 or Win32 application and need it to run somewhere X11 does not exist, because the whole project exists for that situation and the NX11 layer is the piece that makes existing binaries work. Do not adopt it as a desktop window system, since the README calls its own architecture diagram slightly outdated and the project is aimed at embedded and legacy targets, not at a desktop session. Before you build it, read the FAQ files in the doc directory rather than the README alone, because the README points there for the build steps, and check the platform notes, since Android has an application note and the Atari Jaguar needs specific treatment. Expect to work with the source in src/ and to find the documentation thin outside the project site. ## FAQ ### What is Microwindows and what is Nano-X? Microwindows, also called Nano-X, is a small graphical windowing system written in C that implements both the Win32 API and the X11-like Nano-X API for clipped graphics drawing in windows, on Linux, macOS, Android, ELKS, EMSCRIPTEN and other platforms. ### What is the NX11 library in Microwindows? It is an X11 compatibility library built on top of the Nano-X API, which allows X11 applications to be linked and run without recompilation. The FLTK GUI toolkit runs on top of NX11, and the project also provides Xlib support for platforms that have none. ### Which platforms does Microwindows support? The README lists Linux, Mac OS X, Android, ELKS, EMSCRIPTEN, Nuklear GUI, Windows, Raspberry Pi, DOS DJGPP, RTEMS, ECOS, Sony PSP, Atari Jaguar and Nintendo DS, with cross-compiler toolchains for x86, x86_64, ARM, M68K, PowerPC and MIPS in both byte orders. ### How do I build Microwindows? The README says to see the README in microwindows/src plus the faq files in the doc directory, and notes an application note in the doc directory for Android and specific treatment for the Atari Jaguar. An HTML FAQ and architecture document are published on the project site at microwindows.org. ## Sources - [ghaerr/microwindows on GitHub](https://github.com/ghaerr/microwindows) - [Issues](https://github.com/ghaerr/microwindows/issues) - [README](https://github.com/ghaerr/microwindows/blob/master/README.md) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/ghaerr-microwindows