Why JNode?

There seems to be a certain confusion in the community about the motivation of the JNode project and specifically the unusual choice of the Java language for implementing it. I think some explanation is necessary.


JNode is an operating system based on Java technology. Its implementation language is Java because this is the standard language of the Java platform. The Java language has many advantages (as being type safe, relatively readable ) but many of the advantages come from the Java byte code and the Java virtual machine. JNode is not based on the Java platform for the sake of writing it in the Java language as some people might think. One of the most important points of JNode is that the overwhelming majority of its code is compiled to and executed as Java byte code in a safe environment. JNode aims to achieve increased stability, robustness, reliability and performance by choosing the Java byte code as executable code format and executing it within an appropriate virtual machine. The past one and a half decade demonstrated the superior runtime characteristics and reliability of the Java byte code based programs compared to native programs. Moreover this has proven to be so successful that practically the mainstream domains of application software development have largely adopted the execution model where the program translated to a more or less safe byte code run within a dedicated virtual machine. It's among the goals of JNode to extend this model to the complete software stack including the operating system. By JNode itself being translated to Java byte code which is also its primary executable code format, JNode is a metacircular execution environment with respect to the Java byte code This has deep implications regarding future capabilities which can be built into the system and combined with the dynamic, flexible and object oriented nature of the Java byte code opens perspectives to solutions which are impossible or hard to implement in traditional operating systems. Reflection, manageability, dynamic profiling, byte code instrumentation, dynamic class reloading, to mention a couple of remarkable properties of Java code, extended to the level of the whole system and applied by the system to itself opens the road towards self-managing, adaptive, self-inspecting, self-diagnosing and self-healing capabilities in JNode. Here the point is to gather the information from the running system, that is usually gathered by a human operator from a well tooled Java application today, automatically feed it back to the system in a meaningful way and then let the system make appropriate decisions and take actions based on that information.


The JNode operating system internally is based on a virtual machine specially developed for this purpose. This virtual machine takes care of running its own code as well as the code of the rest of the JNode operating system and the applications running on top of it. Sharing of code and resources is maximized among all components and layers of the system. JNode has a flat memory model and protection is based on the inherent safety and type-safety of the Java byte code and the built-in security of the system. These characteristics eliminate the need for context switching and native interface. The executable code is byte code managed by the system-wide unique virtual machine, compiled to native code dynamically with the possibility to make advanced optimization across layers of the system impossible to achieve in the traditional dichotomy of a statically compiled native operating system with statically compiled platform specific native Java virtual machine running on top of it. In JNode the overhead of starting a new Java application can be largely reduced due to the fact that most of the resources needed to run the application have already been set up, warmed up and are ready to be reused within the operating system itself.

JNode also aims to provide an outstanding platform for running Java applications. JNode is a platform created from the ground up by Java programmers with Java tools and Java technology specially for running Java programs. Java programs are currently run on many platforms but on all platforms very often they look & feel like somewhat foreign citizens. Any enthusiast of a particular platform will tell it and most of them will avoid Java and make choices specific to that platform for their tasks. This situation is most visible in desktop use-cases and command line based utilities. In contrast with this, a Java program on JNode is the native program of the platform.

So these are just a couple of ideas to demonstrate that JNode is not being developed simply because 'Java is cool' and 'pure Java' is a supreme value in itself sufficiently compelling to build an operating system around it. JNode by taking the unique path of creating a complete Java program execution environment starting from the most fundamental operating system services up to the application level based on the Java technology itself aims to explore and extend the powerful capabilities of the Java platform to the level of a whole completely standalone and self-sufficient software system and staring from this foundation explore new holistic possibilities in a self-contained, high performance, safe, secure still flexible and dynamic self-managing, adaptive systems design. JNode is not about the Java based development of a Java virtual machine, device driver, JIT compiler, thread scheduler, memory manager or any other particular component of a software system. JNode is about the development of the combination of all these based on the powerful capabilities of the Java platform using a metacircular approach. The focus of JNode is the whole not the part.

JNode 0.2.8 (FOSDEM edition)

Earlier last week JNode 0.2.8 was released. We could also call it the yearly FOSDEM release, which used to happen sometime before this much anticipated free software conference. Unfortunately FOSDEM attendance didn't work out for me this year because I had to cancel the whole trip in the last minute due to a sudden illness. So, my meeting with four other JNode developers and with other free Java developers, my JNode talk & demo and watching quite a few interesting presentations, important for my future work on JNode, didn't happen. Fortunately Peter still made the JNode talk, so our allocated time slot was not lost and I hope the presentations from other talks and maybe several videos will be available soon on the website. I plan to share certain information about JNode in the upcoming blog posts perhaps in more detail than they could have been in my talk.

Regarding JNode 0.2.8, it has many stability improvements backed by Mauve based regression tests and bug fixes but no major completed new features this time, though we made progress with isolates, bjorne shell, and hfs+ file system support among others (see release notes). These features should be available in the upcoming one or two releases.
Improvements in the GUI have made JNode capable of running JEdit as you can see in the screenshot. Most features are working in it, but editing is still hard to use due to problems in the underlaying font support in JNode.

Also the result of general improvents is that besides the recent Servlet and JSP examples PHP code is starting work under JNode by the means of Jetty and the pure Java PHP engine, Quercus. Based on this stack we want to set up an experimental version of the jnode.org portal (which is based on Drupal) as a step towards powering jnode.org by a fully JNode based system sometime in the future.

JNode 0.2.7

Finally  JNode 0.2.7 has been released!

With this release the GUI is getting to a point where small to medium sized real world Swing applications begin to work. It also becomes possible to start developing Swing based tools for administrative tasks in the desktop.

Only to highlight a couple of notable features of this release it's worthy to note that starting from JNode 0.2.7 the complete Swing toolkit of OpenJDK and the majority of AWT is available on JNode and apparently this is the first time when OpenJDK Swing is running on a non-Hotspot-based free JVM. Moreover this JVM runs directly on the hardware without the need for an other operating system. Also notable is that now we provide support for generic VBE based graphics enabling the majority of JNode users to get access to the JNode GUI on real hardware which was possible only for a small fraction of them so far.

Since the Java GUI programming is split to the Swing/AWT and SWT worlds a challenge will be for JNode to support all the SWT based applications out there. Fortunately there is a project, SWTSwing which can play an important role in addressing this problem. SWTSwing implements the native parts of the SWT toolkit on top of Swing providing a pure Java solution. It looks like an ideal fit for JNode. It's interesting to see how certain projects of apparently vague scope and utility make perfect sense in the context of JNode. SWTSwing is not alone! The idea of supporting Eclipse on JNode leads us directly to an other similar project based on SWTSwing: EOS (Eclipse On Swing),  and I could continue the list with a long row of projects for which one could ask why a Java based implementation when mature native implementations already exist? Though that could probably be the topic of an other blog post...

SwingSet2 on JNode

This is the SwingSet2 demo running on JNode with the integrated Swing implementation of OpenJDK. Currently the JNode desktop is based on the Swing JDesktopPane and the JFrame peer is based on JInternalFrame. Therefor SwingSet2 is running on a purely Swing based desktop. More work is needed on the Swing based AWT peers and better Java2D support but I will commit the code soon which makes the above demo possible.

It looks like we can anticipate a really interesting JNode release this summer. : -)

The commencement

I have been working with the Java technology for more than ten years now and JNode was my companion on this road during the last 4 years. Java became a widespread, mature technology, available as free open source software, the Java community has millions of developers and apparently the most favorable conditions have been created so far for an operating system based on the Java technology, what is JNode.

I'm starting this blog primarily to share with a wider audience my thoughts related to JNode and Java development, to inform you about the progress of JNode and its community and to reveal moments from its past and outlooks to its future. 

With the title of my blog I want to express my fascination by the general idea of self-reference and by the capacity of software to so effectively capture this essential principle of life, nature and the universe, a capacity which probably still holds key possibilities for its future evolution.

As an immediate incarnation of this idea I'm quoting the Java Quine I created 5 years ago which though not completely platform independent, it is the shortest of its kind that I know of by the JDK 1.4 level of the Java language:

class Q{public static void main(String[]v){char c=34;
System.out.print(s+c+s+c+';'+'}');}static String s=
"class Q{public static void main(String[]v){char c=34;
System.out.print(s+c+s+c+';'+'}');}static String s=";}

I hope many of You will find interesting things here in the future...