Slashdot Mirror
picoGUI: An X Alternative?
bockman writes "While started as a PDA-oriented project, the picoGUI people seem to be implementing many ideas which I think would be good also for a desktop graphics server ( high-level client/server protocol, presentation layer in the server _but_ modular, application management also modular,...). So I wonder: what would it take (apart porting tons of applications) to make it a suitable alternative to X+[your toolkit of choice]+[your window manager of choice]?"
pico == 1e-12. So if your average GUI takes 1 GB, this one should take 1/1000 byte.
So I wonder: what would it take (apart porting tons of applications) to make it a suitable alternative to X+[your toolkit of choice]+[your window manager of choice]?
It would take a reason to replace X. Sure, there's plenty of papers on how X is atrocious and should be scrapped, but it's a protocol that works well. It's been in use for many years and most implementations are pretty fast. In all my years, I still haven't come across a reason to move away from it. If an alternative comes along that offers something X doesn't, then I'd consider it, but it doesn't look like that will be anytime soon. X meets all my needs.
Is your browser retarded?
Before one embarks on such a nobel product, he or she must be prepared for X conquest. Otherwise, he or she will end up like the dozens of alternative-to-X windowing systems littered strung out across the Internet. Don't be a another casuality of X-crazy fanatics; X can be replaced, but only by time.
"The lesson to be learned is not to take the comments on slashdot too literally." --Vinnie Falco, BearShare
The entrenched X API is the biggest roadblock to projects like these. It's almost easier to put picoGUI into a new OS rather than trying to make it replace X in Linux/BSD/UNIX.
But if the X API can be put on picoGUI, then it's something to think about. Otherwise I'll stick with XFree86, which is getting faster and smaller with each release.
A Government Is a Body of People, Usually Notably Ungoverned
We have Berlin after all. =P
Don't think of it as a flame---it's more like an argument that does 3d6 fire damage
The one thing I'd like to see is a set standard GUI services on top of the core drawing engine. Different widget toolkits would be a thin wrapper on top of these standard services, and different widget toolkits would exist to customize the standard services to each language and development model. This way developers could code to whatever API they enjoy (Qt'ish, GTK+'ish, etc) but since these APIs would map to a common set of services, applications would interoperate perfectly. In fact, with would then be easier to write wrappers for "legacy" apps that use straight GTK+ or Qt.
A deep unwavering belief is a sure sign you're missing something...
It is so sad that many in the linux community are so obsessed with "eye candy" and the latest experimental GUI. The flexiblility of LINUX when it comes to the GUI gives it enough rope to shoot itself in the head with. I know the reason why most of my friends work with MS windows and the Mac OS... there is a uniform user interface that works (flaws and all) fairly well. I don't have to sit there and think... gee do I have widget set X with static libraries Y and did I make the right offerings to the gods of LINUX... you get the picture. So picoGUI looks cool... who gives a sh.... (of course this will be modded as flaimbait... since I don't slobber at every would be GUI posted on slashdot)
Take a look at the screenshots. There are no xeyes running! How can we take any X alternative seriously when they don't bother to port xeyes.
When I first showed my wife Linux, the first thing she asked was "What do those eyes do?" My reply, "Some people use them as a status indicator for predictive multitasking thread optimizer, but mine just look at the cursor." "Cool"
If you provide the X-windows service, then you are an X-server, whether you call yourself one or not. So I'm not sure what it would mean to emulate X. If you somehow support X plus some other features, then that would be more like extending X than emulating it.
Personally I don't have any problem with X. I like it. Most of the sensible complaints I hear about it seem to be coming from people who want features that aren't there yet, or who feel the performance isn't up to snuff. These are almost drowned out by people who don't really seem to understand what X does.
I mean, X is a fairly generic display system, as witnessed by the fact that blackbox, matchbox, twm, fvwm, enlightenment, etc, which all look very different, are all just X clients.
Anyway, it might be possible to address the features issue and still have emulation, but I don't think that performance issues will be solved by emulation. And, when you look at all the graphical programs that use X, it seems kind of hopeless to expect that X will go away and be replaced by something else.
Although, if you could port, say, motif and gtk to some new, non-X system, then you could probably leverage a lot of other stuff over to that system relatively quickly.
MM
--
By including this sig, the copyright holders of this work or collection unreservedly place it in the public domain.
I find that a dubious design decision. I like the fact that I can have many different kinds of widgets and graphics under traditional window systems. For example, for handhelds, I can use something like FLTK, which is very light and does not have much in the way of geometry management, while on desktops, I can use something heavy-weight like Gtk+ or wxX11. Also, there is no widespread agreement of how widget layout should be handled in GUIs.
If you want a widget server like PicoGUI provides, you could easily add that between client applications and an X11 (or Quartz) server.
Eventually, X11 will get replaced by something, but among the current contenders (Windows GDI, Quartz, PicoGUI, Berlin, etc.), I don't see anything that has compelling advantages.
X is a big dumb slow ram hog that's impossible to configure without a lot of help and with no consistant look and feel thanks to the proliferation of widget libraries. Something smaller faster and more elegant with a more consistant interface would go a long way towards making me switch from using Windows as my GUI of choice.
On the other hand, there are a crapload of apps for X and everyone COULD standardize on a widget library and a window manager. Also as computers get faster and storage gets bigger and everything gets cheaper a lot of X's performance problems are sort of going away, kind of like what's happening to Java. The remaining issue (configuration) has come a long way too, so maybe there is no need for an X replacement.
I guess I'm always willing to give something new a try, but the real deciding factor is always software availability. For years MacOS was technically superior to MS-DOS and later Windows, but whenever I asked someone why they didn't switch the first thing they said was "there's no good software." Eventually I came to agree and switched to Windows myself (and also Linux). People will only use PicoGUI if there is good software for it, and nobody will develop for PicoGUI unless there are users. It's a chicken or the egg issue. Of course Linux and KDE and others have been in that situation and now are quite popular. So what it would really take to get many people to use PicoGUI would be a concerted effort on the part of a commited group of developers.
That's my $.02
-73, de n1ywb
www.n1ywb.com
X is a well-designed system which serves everyone's needs, works now, and is compatible across the UNIX world. It would take a lot to displace it.
More to the point, in discussions like this everyone always says... "of course it would have to be backward compatible with X..." But these people fail to understand that the only way to be backward compatible with X is to implement the X protocol stream. And once you do that, ta-da you're an X server once again, just like XFree86.
Of course, if your lovely new GUI doesn't reimplement the X protocol and the client/server model, you render useless decades of program code, from ancient embedded applications all the way to current UNIX ports of OpenOffice and Mozilla, from astronomical observatories to cash registers.
And of course, then you will lose one of the biggest benefits of X: the X protocol stream and the client/server model. D'oh!
X is not going away.
STOP . AMERICA . NOW
And how fast "could it be"? X11 seems to be faster than both GDI and Cocoa/Quartz on comparable hardware in my experience.
(any tweaking hints are welcome)
Most supposed performance problems with X11 seem to be due to the toolkits and desktop environment used. Gnome or KDE on X11 can be a bit sluggish on low-end machines Tweaking hint: use a different desktop environment.
Of course, you can also enable backing store by default in your X11 server, which is how a lot of other window systems achieve their slick look; backing store is disabled in XFree86 by default because well-behaved X11 clients shouldn't rely on it.
PicoGUI is designed with a lot of goals in mind, but for me the largest goal is scalability. I'd like to be able to run one app, with minimal code changes if any, on a PDA, desktop, cell phone, phone, toaster :)
There are also a lot of architectural decisions PicoGUI makes that lends itself to easy and consistent solutions for common problems other GUIs have to deal with. PicoGUI has a theme system that manages everything from drawing the widgets to laying out entire application UIs, all with surprisingly little code. It has a video driver architecture that handles raw framebuffers, accelerator cards, and even esoteric devices like ncurses rendering or text-mode LCDs. PicoGUI's widgets are designed with more of a UNIX philosophy- small but powerful widgets that can be combined in nifty ways.
I didn't originally intend PicoGUI to be a primary GUI for desktop computers. I started it for a PDA project I was working on. But, given how its architecture lends itself well to scalability, it could soon be a good GUI for desktops. Recently PicoGUI gained the ability to run in a "rootless" mode where it acts more like a widget toolkit than a complete GUI. Once PicoGUI has drivers for DirectFB or some other acceleration backend, and a way to run X apps in an emulation mode, it should be able to completely replace X.
In my opinion, the biggest stumbling block to replacing X on the desktop is having accelerated video drivers that work on other GUIs. I've talked to X developers about separating the video drivers into a layer that can be used directly by projects like PicoGUI, GGI, and Fresco, but they had no interest. From what I've seen of X developers, they want all the world to run in X.
-- 2 + 2 = 5, for very large values of 2
Basically, everything depends on X, so you can't really replace X and maintain backwards compatibility. In order to have backwards compatibility, you would need to provide all the services provided by X, so you would, in effect, just be writing a new X server.
If you really want to replace X with some other system, then you could probably get pretty far by just porting gtk and motif over to the new system. This should pick up quite a few apps. I have no idea how hard this would be.
But, by and large, it's silly to constantly rant and rave about X. It's just an abstraction for a video driver that allows you to effortlessly traverse networks. It is so low level, that it almost doesn't make sense to criticize it. And I think many of the critics don't really understand fully what X is.
For example, if you don't like the performance, then that is a complaint against the specific Xserver you are running, not against X itself.
If you don't like the widgets you are using, then that is a complaint against the widget set you are using (motif, gtk, qt, etc.). This has nothing to do with X.
As far as features go, if you really want a feature and X does not provide it, then you have a legitimate complaint. But really, what more do you want from a video (and mouse and keyboard) driver than the ability to get information about GUI events and to paint the screen in any fashion you desire?
To sum up, I don't see that X is inherently problematic. I think that most complaints about it are misplaced, and should be directed elsewhere.
Furthermore, when people talk about replacing X, they seldom seem to appreciate the benefits of allowing the application to connect to the server over the network. This is one of X's strongest points, yet most people seem to want to replace it with what ammounts to a widget set rolled up with a local machine only video driver.
Well, that's my $0.02.
MM
--
By including this sig, the copyright holders of this work or collection unreservedly place it in the public domain.
viGUI? emacsGUI?
http://www.club977.com/ - The 80's Channel!
Your source for commercial free 80's music!
Check out the screen shots for more.
Some information for the curious:
- Micah (the lead developer) compiled some info at http://picogui.org/wiki/view/Main/PicoGUI and http://picogui.org/wiki/view/Main/FAQ
- it is not X. It cannot run X apps. No way. Period.
- it is very early in development. I use it for a few things, specially in my PDA, but it's a living-on-the-edge experience.
- there are client libraries for C and python; there are the beginnings of a tcl library, dunno how usable, and an old perl library which needs work. There is also a waba (java) library, but I don't have any idea of its status.
And now my answer to your question, IMHO:- a terminal widget that runs things like mutt, emacs, lynx|links|w3m
- a web browser; porting mozilla sounds like the obvious choice
- and, of course, apps.
Then again, I'm not sure X has to be replaced. But you're not talking about replacing, you're talking about alternatives... from Apple for blatantly ripping off the Aqua GUI?
;)
Come on guys, lickable buttons and pin stripes are so last year
Say what you will about Windows but at least it's a standard to work against. With Linux it seems there always some pertpetual tinkering...enough already! Enough tool building, now make some apps.
Look how many freeware and shareware files are available for Windows. Sure, they're not open source but a lot of people are still writing apps for Windows. For example, go to hotfiles.com and search for "word processor". Quite a few choices. For Linux, you've got...AbiWord, Maxwell, WordPerfect, StarOffice/OpenOffice.
The point of all this is that most people don't care what's the newest/greatest/most different way of doing something. They just want something that turns on and works. So don't think about replacing X, think about making more applications for the end user.
Blame the clunkiness of the linux desktop on the linux desktop, not on X (in general) or Xfree86 in particular.
There are a lot of concepts associated with X on linux. X, in the form of Xfree86, is at the bottom. Then on top of that there is a widget toolkit (i.e., gtk+ or athena or motif).
Interacting with X is the window manager, which may use a widget toolkit, and which excercises control over placement, size and other characteristics of application windows. Each of these application windows gets to decide how the pixels it has control over should look, within the limitations of the display device. And, in many cases, these applications are built on top of a widget toolkit which may or may not be the same as the one used for the window manager. Then there is the "desktop" which is really just another application.
So, you see, "X" is probably not the cause of the clunkiness you perceive.
On the other hand, if Xfree86 is genuinely too slow, then you should build (or clamor for the building of) a faster x-server.
But don't throw out the whole concept of the x-server, for it gives us many benefits, perhaps most importantly, network transparency.
And, by the way, most people are not saying "Why change? X is ubiquitous!" They are either saying, "it will never happen: X is ubiquitous" or they are saying "Don't change it, because there isn't a superior alternative yet."
I, on the other hand, am saying "don't blame X for problems which lie elsewhere." And, perhaps, "don't put forth an opinion on X if you don't really know what it is."
Oh, and, "the PicoAPI has something like 70 functions in it. Let's not get carried away!"
MM
--
By including this sig, the copyright holders of this work or collection unreservedly place it in the public domain.
The basic concept of X is sound, mature and very farsighted. We have some implementation work to do, but we also need to remember to keep that seperate from the actual value that X provides.
:)
Most people here like UNIX right? You can package all of those X complaints up and apply them to UNIX in general. When you do, Guess what? They are the same arguments. All of the things that make UNIX like systems, such as Linux, a good thing are the same things that drive some people nuts about X.
The reality is that using a *real* computing platform requires a little learning. In the last 4 years, the rate of improvement is astounding really. One or two more years and it is going to be solid.
X is a part of that work and brings with it some serious benefit. Again, I ask: "Why trash all of that, just so we can start all over again with a simpler and more limited system?"
It is not worth it.
There is a trade off between easy to use, and capable. You can also factor in common knowledge to understand how this applies to X today. Lets call this the "happy point".
Right now, there are a lot of people who got started not knowing what network transparent display systems actually mean. This is because the platforms they worked on did not have them.
So common knowledge is low for people coming to Linux right now. So the "happy point" is way toward the ease of use side of things. Makes sense really, because you don't miss what you don't yet understand.
Over the next couple of years a few things are going to happen that will essentially make this point moot.
X configurators will get done for most people. Most of the hard stuff will be abstracted into a few sensible combinations that people need and they will work. Progress so far shows me this will happen.
Some of the brighter ones will start understanding just what X is giving them and will start liking it. Articles, reviews and product feature checklists will start to mention this point.
Remember X is a serious differentator for UNIX like systems. It allows us to do things that make a lot of sense and provide a lot of value.
X server performance will cease to be an issue. There is simply nothing that prevents X from being as fast or faster than the very best frame buffer systems. Nothing. I have old SGI machines with simply *excellent* X servers. They understood X and made it work to its best advantage. The result: 30 Mhz machines that are just as snappy as the machines of today.
Don't tell me X is inherently slow. For each argument, I can point to the source of the problem and that source will be implementation, not the basic premise of X.
So all of this will help to raise common knowledge. As this goes up, that "happy point" will move over toward the capability side of things.
After a couple of iterations, we will wonder why it was such a hassle. I did when learning and it was harder then. Now it is fairly easy. In a couple of years, the things people want most will be in the GUI, for the rest of us, we can continue to meld X into performing whatever display task we want.
Only well planned scalable software with vision does this sort of thing. UNIX does it, thats why we like it, X does it, and that is why we will like it too.
I am *really* tired of hearing X sucks tirades. Is this bash X weekend or what?
Guess I will have to just post X is good tirades each time. Perhaps the truth lies between
Blogging because I can...
X will never be replaced
Removing flexibility for better bandwidth = too many people pissed off! Open Source software supports niche users, and no one is ever going to be able to get around that fact.
Speed is fine IMHO. Maybe (don't know, don't care - I've spent too many hours customizing kde's look&feel settings) X is slower than the Windows GUI, but other factors (gcc + better OS) apparently make up for it, because I find LGX to run faster - of course, that's just my experience.
I don't see why "widget tunnelling" instead of X tunnelling can't do the same thing picoGUI does as far as bandwidth is concerned. So someone figures out how to tunneling Qt and gtk in addition to just basic X info and magically, X defeats bandwidth consumption by taking its "flaw" dependency on toolkits and turning it into the solution.
Sure, speed probably won't get a boost - but on my 128mb RAM P3-733, speed is fine, and an unnoticeable increase in speed is not worth the loss of the personality we can add to our interfaces on X today.
OTOH, I have no idea what I'm talking about.
As many other people have pointed out, X is fine. Problems people have with "X" are really problems with either the implementation of X, or problems with their widget set. People complain X is slow. Now, X isn't slow: you're using a crappy implementation, or crappy drivers. Its not X's fault. Get better drivers, get a better or update implementation. Go to XFree86.org or try out Accelerated X. If you want a certain feature that's not there, its probably your widget set.
In short, before you say X sucks, identify your problems with it, and ask some experts about how to resolve them.
One thing that I will criticize X for, however, is that they don't enforce some kind of standard for interfaces. One thing Linux does need is standardized interfaces and key combinations between applications. There doesn't need to be one standard, but apps installed on a user's computer should all obey the user-defined standards. CTRL-V should always past...it shouldn't be CTRL-V or ALT-V or CTRL-P depending on the app. Same thing with menu's and stuff. Why should every developer have to reinvent the wheel? And why should the user have to reorient himself for basic key combinations for every program?
social sciences can never use experience to verify their statemen
Are we not changing resolutions when you "ctrl, alt, keypad +|-??????
No. Ok, maybe the monitor changes resolutions. Your desktop and all applications aren't aware of any change (like they would be in MS Windows for instance). Once you press Alt+/- in Xfree86 your entire UI experient is degraded by the constant need to shove around the viewport with the mouse cursor.
That feature is worthless for anything but a quick zoom-in on an image, or for testing refresh-rate configurations.
Basically, everything depends on Windows, so you can't really replace Windows and maintain backwards compatibility. In order to have backwards compatibility, you would need to provide all the services provided by Windows, so you would, in effect, just be writing a new Windows.
If you really want to replace Windows with some other system, then you could probably get pretty far by just porting MS Office and Internet Explorer over to the new system. This should pick up quite a few apps. I have no idea how hard this would be.
But, by and large, it's silly to constantly rant and rave about Windows. It's just an abstraction for hardware that allows you to effortlessly run multiple programs. It is so low level, that it almost doesn't make sense to criticize it. And I think many of the critics don't really understand fully what Windows is.
For example, if you don't like the performance, then that is a complaint against the specific hardware or drivers you are running, not against Windows itself.
If you don't like the program crashing, then that is a complaint against the programs you are using (Office, IE, ICQ, etc.). This has nothing to do with Windows.
As far as features go, if you really want a feature and Windows does not provide it, then you have a legitimate complaint. But really, what more do you want from a video (and mouse and keyboard) driver than the ability to get information about GUI events and to paint the screen in any fashion you desire?
To sum up, I don't see that Windows is inherently problematic. I think that most complaints about it are misplaced, and should be directed elsewhere.
Furthermore, when people talk about replacing Windows, they seldom seem to appreciate the benefits of allowing multiple applications to run on screen at once. This is one of Windows's strongest points, yet most people seem to want to replace it with what amounts to software rolled up with a kernel.
Well, that's my $0.02.
This is SO educational! -- Kintaro Oe
Anyone who's ever used an SGI would agree that they've made about as slick an X server as possible, largely because they've done such a good job integrating with hardware. It's smooth even on older computers, and the widgets (modified from Motif) look great. However, the underlying problems in X go way beyond the issues of specific implementations which shall remain nameless. Try reading the O'Reilly books like "Xlib Programming Manual" sometime, and see how long it takes for your brains to leak out your ears. Apple, on the other hand, has come out with a relatively consistent and polished API. Personally, I think Aqua is a bitch to actually use and prefer to deal with the clumsiness of Linux/XFree86 for running apps, but based on what I've read I'd much rather develop for OS X than Linux. I suppose I could use one of the many toolkits, but it'd be nice if I had one to choose from that didn't suck.
You got complaints with XFree development, then "throw your stone into the soup," with your own ineffable coding skills -- or hold your criticism. To work a weary truism, you look a gift horse in the mouth!
The XFree86 effort is about 10 years old. Twenty years ago (I was there) we had dedicated, proprietary VECTOR graphics terminals, one per PDP-11, please! Raster graphics were a dream, waiting for advances in (gasp!) bubble-memory... Never happened that way.
The XFree VOLUNTEERS took the X11r5-6 standard and reproduced it for free commodity systems. In six or seven years, they equaled proprietary vendor efforts, without the benefit of proprietary access to hardware! In the past three years, these developers have been working to advance X11 beyond any earlier realization.
X is a good design, and extensible enough to be with us still today. Sure, I would have been ecstatic if NeWS had prevailed politically in the 80's Unix wars, or that NeXT's DP had grown up - but the DEC committee won out for openness, and number of players invited to the table. The downside of comittee design: Xlib sucked, and every toolkit ontop of Xlib perprtrated the crimes. It's still just a library - better ones are here and arriving - if nonstandard. Even JZW's famous excoriation of X11 is based on Xlib and Motif toolkits, not X11 architecture or design features. These are not dismissable any easier than is Unix.
Paraphrasing the truism, I would advance that "Those ignorant of X11 are doomed to re-invent it -- badly."
"Flyin' in just a sweet place,
Never been known to fail..."
To explain:
- with X protocol, in order to draw, say, a pushbutton, the client says to the server things like : make a rectangle filled with color X, draw a line, etc... (the application programmers don't see this because this is what the GUI toolkits are for)
- with picoGUI, the client only says: draw a button. It's the server that take cares of details, according to the currently loaded theme.
This brings a couple of advantages:To come to your point, no, picoGUI cannont embed the X protocol (it would be against its basic approach). But il could be possible (though not easy) to make 'compatible library' that traslates GTK+ API (or QT API) into the picoGUI API/protocol.
Ciao
----
FB
With Fresco you get network transparency. We use CORBA to develop Fresco, so that's a free bonux. I know all those CORBA is bloated, jadajada, arguments, but I am confinced they do not apply to Fresco: We knew from the very beginning we will use CORBA and have taken its strength and weaknesses into account designing the overall system.
Anyway: Fresco is network transparent and it uses way less bandwidth then X. The protocol is so much more high level! The small demo we got only uses 1.9kBit/s to hold the connection with the remote server. I don't know any numbers for X, but VNC needs 800kBit/s when used to 'forward' the Fresco server to another computer via its protocol. It was using the same demo but with less then half the screensize the original server ran at. Not that the screensize does matter with Fresco. Of course I did the same things with the window (moved, rotated, shaded it, opened subwindows, etc.) using VNC to forward the display and running the Fresco server locally and having the client connect from the remote maschine.
Fresco allows for different 'WindowManagers' (of course we call them 'DesktopKit'). Those are loaded into the server and are not normal clients like in X, that's the basic difference.
You got a good point wrt. the decades of testing. Obviously neither PicoGUI nor Fresco can give you that. But then there's less testing needed: The servers have much less code. All the graphic-card handling stuff is separated out into libraries like SDL, GGI or whatever. Those have been thouroghly tested for a while now, makeing that critical component rather relyable.
Hardware support is not as bad as you imagine. Since neither PicoGUI nor Fresco (nor any other project in a sane mind) is writting graphic drivers themselves! There are excellent libraries, kernel modules, etc. around to do that. If there are only X-drivers, then you can still run on X-windows (it spoils the purpose of replacing X, I know:-) till one of the farious 'rip the drivers out of X'-projects is successful. There are several of those arround even now.
Finally you use the if it works, don't fix it argument. I like that, but obviously X does not work or there wouldn't be so many X-extensions getting actively developed. As I see it, you can either extend X (to Y or whatever you want to call it) or work on something new like PicoGUI or Fresco or some other project. In both cases you end up with a system where applications developed for it will not run legacy X-Systems (without considerable efford of the Programmer/Toolkit writer). Once you use an extension your application breaks for X-without-said-extension. So baiscally you end up with a system not 'forwardward' compatible with vanilla X, independent of wether you extend X or write something new. X-with-extension is of course backward compatible, but a compatibility layer can be added to another system later if need be. That's a lot of work, agreed, but the very simple case of just letting a X-server run in a window was allready demonstrated in Fresco.
Regards, Tobias
Some URLs you might find interessting: the Fresco Homepage, a short comparison of Fresco and X (the server is slow, please bear with it), finally a page listing among other things Other GUI Projects I found to be interesting for various reasons (both dead and alive;-).
Regards, Tobias
Instead, fix the current one.
Current wheel ( X ) comes in several colors ( platforms ), the protocol is universal ( remote display too ). X is mature, and has millions of programs written for it NOW.. not SOMEDAY..
It has all the functional components that is needed in a graphic subsystem.
Sure, its *not* perfect, but spend the time enhancing it instead of tossing it out.
Plus people need to learn to sepreate the X subsystem to the GUI on top before they start comparing things... One cant accurately compare wheels to bricks..
---- Booth was a patriot ----
Wow, PicoGUI is pretty impressive.
Yes, but it's fundamentally different from XWT. I would not choose PicoGUI for an intranet. Hell, I don't think I'd choose PicoGUI for an embedded project. They decided to use their own protocol for server/client communications, which is something I don't understand/agree with. It's YAP - Yet Another Protocol. Yes, XMLRPC would have a larger overhead in terms of larger message size and a mini XML parser, but they could have used straight HTTP GET/POST, CORBA or something smaller and already out.
I also can't give PicoGUI to a web monkey and get them to design impressive widgets and therefore apps with it.
I'll stick to XWT, thanks. :-) And for embedded I would probably choose microwindows or maybe even fresco. The integer-only aspect of PicoGUI is nice but the reality is that anything that has a display requiring a more complex GUI will have enough horsepower to drive one of the bigger windowing toolkits.
People don't seem to understand that PicoGUI is designed completely different.
...) are independently coming to similar design decisions should be a strong hint that they might be on to something.
Like Fresco, the idea is to put the widgets and window management on the server side. And why wouldn't it be there?
- it does NOT mean you can't replace your widgets with others with a different behaviour, look, feel, whatever!
- picoGUI is scalable: not visually scalable, but the same program can display something using text-only lcd, console, or full-fledged graphics - and in all cases it's usable and adapated!.
- it's about separating representation from content!!! isn't that what web developers have been struggling with too? (HTML + CSS)
- the display hardware is on the server side, so having as much as possible on the (display) server side will give you a lot of opportunities to take advantage of hardware acceleration (see Fresco, that uses opengl HW acceleration for everything, including widgets etc etc)
There's always a strong resistance against change - I wish people would be able to look towards the future a bit more. And in any case, we're not dropping X just yet, it's just about exploring new alternatives, that might end up technically better (isn't that what Open Source is about). These projects are not about making Yet Another Window Manager. They're not about eyecandy either.
The fact that more and more projects (Fresco, picoGUI,
Please, just read up a little bit on both the projects I've mentioned.
The reason X is mistaken for GTK is because most normal average computer users don't know the difference. One sees GTK based programmes and window managers such as the GIMP and GNOME and assumes that that IS Linux. Those that use SuSE see KDE and wonder why ALL programmes don't use that (including the GIMP, notwithstanding the fact that GTK comes from the GIMP). The point is that average users don't know or care why the GTK toolkit is so incedibly ugly (for them looks DO matter) or why X is not very flexible or easy to configure. They just give up and either use KDE or go back to Windows or use Mac OSX.
Linux needs one standard windowing protocol and system, either GNOME or KDE, not both. The continual clashing is hurting Linux and making it harder for developers. Time for a change.
But to answer the question:
1. Any "captive" application - think stripped browser on a kiosk - could use Pico.
2. If the TOOLKITS which are (or should be) platform-neutral are ported. Qt is probably a good candidate. The Zaurus already runs QPE and Pico separately, but it isn't much of a leap to do QPE (already over Qt) over PicoGUI.
But before you get too excited, the code is still in an early state, at least as far as compiling on every platform. It keeps client-server though.
And I need to address some other comments about X.
First, it isn't that slow, and one of the problems is that a lot of software is assuming SHM or other extensions that force things to be local.
Second, dxcp or other programs can compress the X stream to make it usable over some slower links and would reduce bandwidth in any case.
Third, if you are doing remote control or something similar, VNC or something similar is the correct solution.
Fourth, X is the basic set of protocols. But in many references they mean X plus every toolkit, extension, and window manager and probably a few applications. Some things are only big because of these accretions.
Citrix, or almost anything else on Windows is a hack since Windows was never designed to work remotely.
You can criticize X all you want, but it is opensource, so you can fix or enhance the problems, and it seems to work well enough to allow the wide adoption.
And PicoGUI addresses one of the major points - the need for a lighter weight system for embedded and small computer use.
There's nothing wrong with X. Most of the problems that people have with X don't have anything to do with the stability of X, they have to do with the API/toolkit, environment (KDE or GNOME), and/or the window manager. Those are the entities that "crash" the GUI. The problem is that a lot of newbies and even moderate users are not familiar enough with the system to understand this. They assume that because X disappeared off their screen, that X is to blame. I used to think this way as well, but after having gotten into Linux really in depth and compiled X a few times, I see now that the real culprit are the X clients, not the X server itself. The only thing the X server does that would lead someone to this conclusion is that it usually restarts: (Screen goes black, and X restarts, either resulting in just the X cursor on the checked background, or a DM pops up 'XDM, KDM, GDM, etc...' And, last not not least, if you are starting X with 'startx' (unmanaged), then yes... the GUI just disappears and takes you back to a *sh shell.)
:( ) Of course, the best feature hands down is the network transparency. Running X apps remotely and having them display on a local system is just great and much more flexible than Windows XP RDP. Especially since you can have applications running on several different systems all displaying on the same desktop (not in separate windows like RDP). Combine this with the Low Bandwidth Extensions (lbx) and you can do this over slow links with speeds that are pretty close to RDP. Your local X display becomes the main head for multiple servers this way! How cool is that?
The latest realease of X actually has a lot of really great features that a lot of users are unaware of. Features that put it on par, if not slightly beyond the Windows GUI. (Mac OSX still has X beat
Of course, there is plenty of antialiasing and subpixel shading (for laptops) that again is on par with Windows XP's GUI.
Overall, X is actually extremely stable, but ti does need a few improvements. I think the biggest flaw in X that makes people think it's unstable is that the session needs to restart when an app or client session dies. If X could be kept active and just allow the clients or apps to reconnect without ever going away, I think you would see a lot of people change their tune about X. It would also be nice if X allowed for reconnection of stateful sessions (Like XP allows for multiple users to be logged in with apps running). I'm not sure, but I think Xnest might allow for this, although I haven't tried it.
The biggest problem with X is that a lot of the extra functionality is not easy to use. lbxproxy (for low bandwidth connections) could use a nice GUI based tool combines with ssh to make setup really simple. For example:
1. You run the LBX Proxy Connector GUI on your local system. You enter the IP address of the remote system, select whether you want to run a specific app or a complete session (GNOME, KDE, etc...) and then click the connect button.
2. In the background the Proxy connector establishes an ssh connection to the remote system and executes the appropriate ssh commands to run the remote app or environment with lbx, and establish an ssh tunnel.
3. Locally, you see the app appear on your current desktop, or a new X display starts and runs the remote environment.
That would just be damn cool. You would get compression, encryption and either just the remote apps you need, or an entire remote session (KDE or GNOME).
So... please don't say that we need to get rid of X. Having alternatives to it that are useful in certain situations is fine, but X really is a very cutting edge and flexible system that needs a few "ease of use" apps added to it.
Also it is quite possible that X can suck in it's own ways even though a low-level protocol is a good idea. The fact that X is bad does not prove that every single part of it's design is bad.
First, plenty of toolits are on Windows. I recieve about 10 times more interest from Windows programmers who do not even know how to run a file from a command line for fltk than I get from Linux users. Also you can easily tell that virtually all large graphics systems and some of MicroSoft's own work (Word, for instance) do not use their "toolkit".
Also if X had been a "toolkit" like you seem to want, it would have been the Athena toolkit that existed in 1984. I'm sure the fact that everything is drawn in two colors (black & white, which a "configuration" that reversed them) would have been deeply engrained into it. There would also be those lovely scrollbars where only the middle mouse button did what you expected.
Fortunately this did not happen. All of X's mistakes are because the graphics were designed in 1984 (or earlier, really). But oddly enough bad graphics *can* emulate stuff that was not imagined 20 years later, so X is still working. Bad toolkits cannot do anything.
Someday there may be a replacement for "buttons" and "menus" and "icons" that is far more user friendly (no, I don't know what, if I did I would be writing it!) and when that happens the people who wrote toolkits into the system are going to look as stupid and backward as the people who wrote record-management into the disk file systems.
What is needed is for the people who can to stop doing the easy and "fun" part of writing "toolkits" (I know, as I am also a toolkit author) and start doing the HARD stuff, like drawing an arbitrary transformation of an image with error diffusion, something we have known how to do since about 1987 but for some reason is not in any of the graphics systems even today. Drawing every single character in UTF-8 with a single call that takes a string would also be nice.
OK, I'll come out of the woodwork like every other worm that's lived, loved and hated X for years.
I think X was ahead of its time with the network view of a server accepting requests.
In hindsight, no fault of the original developers, the problem is now that it was implemented before the advent of newer standards in network communications such as http and XML. Yes, the existing infrastructure works like a draft horse. But it would have a better future if it didn't do things its own way but relied on other standards, even if those standards were later in coming.
And, honestly, X didn't flow smoothly into vector based (PostScript) and 3D systems (OpenGL) except as "extensions" that are obviously afterthoughts. Sun's NeWS didn't win. And OpenGL applications under XGL behave differently than pure X applications.
It would be nice if a new frame buffer device manager would be written that incorporates some of those ideas and yet retains the network awareness of X, which I think is one of its strengths.
A well-designed successor to X should be layerable either below X or above X during a transition.
"Provided by the management for your protection."