Network Transparent Widgets short from NTW, is a protocol and application framework that allows a single server to serve thousands of remote GUI applications.
The client applications are nearly indistinguishable from local, native applications. The protocol is language and architecture neutral. Server language bindings for C and Java are in heavy development.
Here are some key features of "Network Transparent Widgets":
Speed: Remote apps can run at a speed which is nearly indistinguishable from a locally running application. Since the client draws the widgets natively, it's not necessary to transfer graphical data, only widget state data. This can be done asynchronously, so the responsiveness of the UI never suffers.
Persistence: It's just as easy to write the ntw protocol data to disk as it is to the network, so the state of the entire gui application can be easily saved. This also happens transparently, so the developer doesn't have to spend any time loading and saving data. Also, if a network connection dies or the client computer loses power, the application can be restarted from the point of failure at the next connection.
Portability: using the protocol, an ntw server application running on a Unix machine could talk to an ntw client for Windows, and vice versa. So a developer could write a program on Linux that could be run from any OS without any porting necessary. Any language or platform that can read and write data to a network can use the protocol to create gui apps.
Scalability: Since the ntw server does not store or draw widget graphics, the memory and computational overhead of running an ntw application is much less than a comparable X Window application. A low end machine could easily serve hundreds of remote clients.
Productivity: Users can run ntw apps without installing anything but the client. Developers can release new versions of their apps without the users having to do anything, much like a web page.
The current reference implementation of the client implements most of the widgets in the Gtk toolkit, and is written in C using the GTK+ 2.0 toolkit for drawing the widgets and handling events. It compiles and runs on FreeBSD, Linux, and Windows, and likely other Unix variants also. You'll need the GTK+ toolkit installed to run the client, and the GTK+ development headers to compile it.
The source code also include a server reference implementation and a sample server application. The "server" is really a set of C language bindings to functions that create and send ntw widget data. The bindings can be used in much the same way as any other GUI toolkit. See the file "ntwtest.c" for the example application. It's been tested on FreeBSD, Linux, and Windows XP. The server library should compile and run on most systems with a C compiler and support for sockets, without the need for any additional libraries.
The protocol is defined by the two header files, ntw.h and ntw_signals.h. These are C header files that describe exactly the byte layout for each of the widgets and all of the opcodes and events that can be sent.
There are still some widgets missing, and some of the signals raised by GTK are not yet handled in the protocol. This will be fixed in the near future.
Note: Although the reference implementation is coded in GTK, the NTW protocol is designed to be independent of any particular widget toolkit. GTK was picked due to favorable design features and a favorable license.
What's New in This Release:
· 02JUL06 - Fixed bug in update.c where spin_button was switched with slider
· 02JUL06 - Removed status field from image_buffer widget protocol