Build your own desktop


Where we’re at Winter 2002


Our story so far…


Stardock created Object Desktop to allow users to transform Windows into a customized solution. The goal being that individuals and companies can tailor Windows to meet their specific needs. Object Desktop does this through its components. These components each customize a particular part of Windows. These components include WindowBlinds, ObjectBar, IconPackager, ControlCenter, and DesktopX.


DesktopX is designed to handle the actual desktop (ObjectBar handles the bars/wharfs and WindowBlinds the GUI itself). It does this by extending the shell to support true objects. These objects can be combined together to create virtually anything imaginable – apps, utils, bars, wharfs, super icons, etc.



Typical settings dialog for an object.


What’s made DesktopX’s objects so flexible is a combination of four things:

1)      Objects can be any size or shape (icons are all identical in size with a fixed resolution such as 32x32).

2)      Objects can have any number of different states (normal, mouse over, mouse down, mouse away and custom states)

3)      Objects can send and receive messages to the operating system, to applications, and to other objects.

4)      Object position can be set by the user and it will stay in that exact position or relative position regardless of screen resolution.


Objects can thus be used together to create virtually anything a user imagines.



Take a close look at the above screenshot.  It’s built using hundreds of objects. When those objects are put together, they can form anything. And each of those objects can send and receive messages and react to those messages.


This means one can literally draw up their user interface and put it together. Normally this would require a considerable amount of programming. But DesktopX handles all of the underlying messaging and drawing routines that normally the developer would have to create.


DesktopX 1.0 also included a basic plugin design that allowed developers to extend what was built into DesktopX. With it, users created everything from email checking objects to disk space monitoring objects. DesktopX became very popular with end users looking for a flexible way of creating their own unique desktops either for a company, a kiosk, or individual use.


A nice kids desktop



DesktopX: The Road ahead


Stardock also learned a lot of lessons from the initial release of DesktopX. While its architecture was powerful, it required too much programming knowledge to extend it. The net result is that the vast majority of objects and themes were primarily cosmetic in nature. These objects were a sort of “super icon”. Most developers simply do not want to invest time into a proprietary plugin format that was fairly limited in scope.


To this end, Stardock began designing what is currently known internally as “DesktopX NG” (Next Generation). The goal of DesktopX NG is to make Microsoft COM components/objects be handled as DesktopX objects. And to make it easier to extend DesktopX features, Stardock decided to make it possible to use scripting. However, instead of developing its own proprietary scripting language, Stardock used Windows Scripting Host. This means that a user can use any scripting language available on that PC such as VBScript, Javascript,  REXX, Perl to anything the user has. DesktopX objects and COM objects can be accessed directly from the script.  Moreover, DesktopX NG will feature “Wrappers”. COM objects are complex and as the name COM (Component object model) implies do not do very much individually, it is when they are combined together that they become functional. For example, there are several Internet Explorer COM objects. The web browser is just one.  Wrappers allow users to have a user friendly front end to these COM objects. This way, theme designers and end users alike will be able to effectively use COM objects without programming experience. Traditionally this would have been possibly only through the use of Visual Basic or some other programming language. But DesktopX is the first product that truly brings these features to the masses.


But DesktopX NG is some ways off, in the meantime, Stardock is delivering some of this in DesktopX 1.1.


DesktopX 1.1


With DesktopX 1.1, users are not confined to merely objects based on plugins or images. Every COM object on the system can be accessed and treated as a DesktopX object. And because DesktopX objects can send and receive messages, this means a much wider range of “Developer” can build custom applications. What was once only possible with a considerable amount of Visual Basic or Delphi programming can now be accomplished in a few clicks and a few lines of VBScript or Javascript to have the objects talk to each other. And since most modern applications are actually a collection of COM objects, that means users can create some incredible things. No longer are people dependent on what plugins someone has happened to have made. Now, every COM object is, in effect, a “plugin” already ready to use. 


The above screenshot to a developer is like a kid in a candy store. There are so many things to choose from and with COM being the “pluginformat, it means for developers that DesktopX is a stepping stone for ambitious developers to learn how to create next generation software that is applicable far beyond just DesktopX. DesktopX also supports a new proprietary Plugin standard called SDPlugin for C++ developers who want a relatively easy way to create plugins that will work on both DesktopX and ObjectBar as a stepping stone to Microsoft’s COM.


The above example also demonstrates the need for “Wrappers” that will arrive with DesktopX NG.  A developer can use the scripting language of their choice to put these COM objects together into something useful, but a typical user would be intimidated by it. Wrappers put a user friendly interface in front of this which in turn talk to the various COM objects for the user.


But clearly for developers, the ability to access all of this and be able to create software that is immediately useable is compelling. It’s particularly compelling since the knowledge learned in creating these objects and scripts is directly transferable to ones career in software development (A DesktopX object that displays a graph of how many users are downloading a particular skin on a day by day basis using VB Script and an .asp page is the same code one would use to do it with visual basic (except the developer would also have to handle all the visual display and events which DesktopX handles for them).


DesktopX 1.1 in action


What are some examples of DesktopX 1.1 in action? Here are a few compound object examples:


Example #1: A new headling reader.


How about an object that automatically every so often queries a favorite website to see if its news items have changed. How much work would this normally be if you wanted something on your desktop that just sits there and does it? Do it in Visual Basic and it would take a couple of hours and use several megabytes of RAM.  Do it with DesktopX 1.1 and it can be done in a few minutes. One literally creates the object, right clicks on it and uses DXScript, chooses VB Script and writes the above code (26 lines total including spaces). That’s it. You now have a news item object that sits on your desktop. How much RAM does this use? 7 megabytes and that includes DesktopX itself. Most of that RAM is the Internet explorer object that it had to create.  DesktopX isn’t just easier than using a programming language to create a stand alone program, it uses a lot fewer resources in doing it.


Example #2: Stock Ticker

This is actually the same as example 1 except instead of getting news, it queries the stock price on an item that the user has inputted. Time to create – about the same amount as the first example.


Example #3: Custom Instant Messaging

Microsoft’s new Instant Messenger is actually a collection of COM objects. This means that it can be accessed as parts in DesktopX.  The upcoming IM object example Stardock will be releasing shortly will allow users to actually have a individual objects that can correspond to individual users. When the user double clicks on the object, it will let them send a message to the object’s user. Similarly, when a message is received, it can respond to that (so in the example you could have the object actually be the face of that person. When they send a message to you, you could have them “speak” (play a WAV file) and change their face.


Example #4: A ball and a bat

To demonstrate the real time features, Stardock will be releasing two objects – a ball and a bat. The ball will float on the desktop and the bat will be another object that the user can pick up and whack the ball which will go flying around the screen. It’s a simple example to demonstrate how easily one can have one object interact with another.


DesktopX possibilities


Microsoft is putting together its .NET initiative and no program is more ready to take advantage of .NET than DesktopX. DesktopX will be able to access those .NET services directly and provide developers an easy way to access .NET technologies. In many ways, DesktopX is “OpenDoc” and “Cairo” on the desktop brought to reality. OpenDoc’s goal was to allow developers to interact with different “parts” in different ways to lower development costs and make it much easier for corporations to create custom environments.  This is what DesktopX can do and will continue to make such customization and deployment increasingly easier as it moves towards the DesktopX NG goal.



DesktopX object and theme library:


DesktopX DXScript tutorial:


DesktopX home page:


Object Desktop home page:


Stardock home page:


Other Info

DesktopX is available stand alone for $19.95.  Users can get the complete Object Desktop for $49.95 which also includes a 1 year subscription to