Slashdot Mirror
The XFree86 Fork() Saga Continues
Mortimer.CA writes "An article up on OSNews about the XFree story
mentioned earlier. Included is: replacing fontconfig with Sun's stsf; XFree86 co-founder David Wexelblat saying that XFree is today obsolete and should be changed; Keith Packard replying, and more."
Time for Fresco?
I have a bad feling that this is goint to be one of those situations where *every* party involved is both right and wrong on some level. Even uglier is the possibility that this could occur on the *same* level. The fact that situations like this could arise in the first place tells me that maybe the architecture of XFree86 (the ideas underlying the code itself) is overly complex for today's needs.
Or another possibility: maybe the way XFree86 is currently implemented by the major *nix vendors is overly complex by default.
Either way, both the situation and the implementation are starting to look really messy.
C|N>K
Do you people recall the Armageddon textfile that got post on /. several times ? Here a little quote from the text.
well you could easily come up and tell me to simply not use GNOME and let them do whatever they like. Well, you are right with that but things are more complicated nowadays. GNOME is influencing a lot of third party projects such as XFree86 which recently added a lot of GNOME components into their CVS repository. Please know that with the next coming XFree86 version you get a lot of GNOME components without even knowing it. code like, GNOME-XML, pkgconfig, fontconfig, xcursor and xft2 were mainly written by people who're heavily involved into GNOME development. Also the GIMP is maturing more and more into getting the look and feel of a native GNOME application. The CVS version of the GIMP has a lot of GNOME pixmaps inside and they are heavily working on integrate the GIMP into GNOME. If not today but the direction is sure and i fear the day this gonna happen.
And this will happen with an Forked XFREE. It matures more and more into a GNOME dependant piece of Software. Exactly that guy who's responsible adding all sorts of GNOME material to it will now make XFREE mature into some GNOME dependant component.
Havoc Pennington (GNOME) works on XFREE,
Owen Taylor (GTK+) works on XFREE,
Jim Gettys (XFREE) and GNOME FOUNDATION president,
Keith Packard (XFREE) and GNOME developer.
I recently saw somebody try to contribute a new driver to XFree86. He was told that he was welcome to contribute the driver, but that he wouldn't be allowed write access to it once he had handed it over. What a ridiculous policy!
The thing is, drivers can be released independently of X itself. For ATI Radeons, for example, there are at least 3 different drivers they can use. It would be nice if somebody set up a website with a page for each video card (or family of cards) that had links to all of the available video drivers for that card. Even better would be if such a website could act as a catalyst for uniting these independent driver developers so that, for example, the GATOS radeon driver developers and the DRI radeon driver developers could combine the best aspects of their drivers. This could possibly help route around the blockage that the XFree86 project too often represents.
Actually, I think that such "hardware-centric clearing houses" would be useful for all kinds of hardware, not just video cards. Look at linuxprinting.org to see how well it can work.
-DA
X really needs to standardize itself. Copying and pasting is a bitch....X is heavy at times too and somewhat bloated. Change would be greatly welcomed...or a new X-Windows engine...
I still remember the transition from X10 to X11.
However, version 11 is almost 15 years old and we
never saw any version 12 (not that I beleive version numbering is any important).
Although I saw some nice extensions being added to the X protocol, there are many parts of the X window system that are now obsolete.
For instance the standard X11 font rendering system looks like it has been kept in the stone age (only recently the Xft extension solved part of the problem).
I really like the network transparency of X and the client-server model, because of all it's advantages and, if you look at it in detail, you will be surprised that it doesn't impose any performance penalty: because of the way the X protocol is implemented, commands are queued by the client and are sent to the server in batches, in order to minimize client/server context switching.
However, in the last 12 years we have seen the graphics hardware improove a lotm but the core X system didn't improove almost anything.
Now we have hardware capable of displaying full motion video, hardware video decompressing, anti-aliasing, alhpa-blending and transparency, 3D, etc.
Meanwhile, X got some extensions to support some of these features, but there are no "standard" APIs and the evolution has been very slow.
X is great, and many of the complaints about X that I regularly read here in
My question: does stsf use it's own font renderer? I highly doubt they came up with something nicer than freetype without anybody really making a buzz about it.
A deep unwavering belief is a sure sign you're missing something...
I spent a brief time working as a contractor for a Linux distributor (now defunct). During that time, I was given the task of maintaining portions of XFree86's XInput and DRI code. What I saw, I didn't like.
Efforts to extend XFree86 to support modern graphics capabilities (XRender, Xft, R&R) are floundering because the level of skill needed to develop and maintain them is simply too high. The XFree86 codebase reinvents many wheels, is difficult to maintain and really does carry a lot of legacy footwork that makes it difficult to work with.
That said, XFree86 works amazingly well for what it is. I just don't think XFree86 development is sustainable. The same effects can be achieved with a thin layer like DirectFB without the overhead. You get the same functionality, usually better performant and with far less code necessary in the implementation. Network transparency can easily be provided by modern component object models like GNOME's Bonobo and KDE's Kparts, with the added bonus that clients are thin and so still usable over a high-latency network.
I wouldn't go so far as to call XFree86 obsolete, but the technologies upon which it's based certainly are.
As I can see, the "fight" is between having very flexible, transparently remote thin client GUI and localy optimized fast workstation GUI. First case is X11 and the second are a couple of new projects like SVGAlib, directfb, DDI, GGI etc... But with such a fragmentation or (calling it another way) variety of projects we are still in troubles missing good gfx card drivers (full MPEG-2D-3D acceleration, tv-ins/outs, for all new chipsets and a few or older ones)... So my question is if it's posible to separate X11 from it's drivers and having those as separate project... and then build on them whatever GUI API you want including development of X11... but having hardware driver building effort focused on one project... like you have only one kernel project that takes care of your hardware and many apps that may duplicate their functions...
Just some thoughts anyway...
Is it just me or is it a little bit cheeky that David W has a say in this at all. It's not like A) he is hacking Xfree anymore, or even using UNIX for that matter. He's been using Windows since Myst came out, for crying out loud. I read the emails, and when you have folks like Keith, Alan, Owen, and Havoc complaining about how XFree is run then isn't it likely that something is actually wrong?
Many people including me would like to see things like transparency and hardware 3d stuff. We keep annoying the developers with this requests. We see it done in windows and (in a blaze of ignorance) we ask ourselfs why this can't be done in X. I personally don't understand why introducing hardware rendered stuff on X contradicts network transparency. So please enlighten me.
I don't agree with Havoc Pennington on many things (like usability matters), but I do agree with this. Keep the client-server model, it's virtually free (wrt resource costs). The real performance sink is in the rendering of fonts, opengl, window managing, redrawing et al. X11 just needs to catch up with the capabilities of current graphics hardware. There's really not much wrong with it, besides that it lags behind somewhat.
This fork might be just the kick in the arse XFree86 needs to get it up to speed again. Nothing like a little ruckus amongst the developers to get the creative blood flowing again. Go Keith!
...after reading your long message, and also reading David Wexelblat's message, and reading all the stuff that came before, it's pretty clear to me: the X Core Team doesn't want to talk. They don't want outside input, they've deluded themselves into thinking that other Open Source projects are just as closed as they are, and they really don't see where all these outsiders get the right to have an opinion. They ask why you (Keith) didn't open a discussion with them, but then act hostile to nearly everything that is discussed.
I don't know how to write a driver for X, but I do know people. And you're banging your head against a wall as long as you try to work within their system. Good luck with whatever you decide.
My Greasemonkey scripts for Digg &
- pluggable implementations (on Linux alone, there's XFree86, MetroX, Accelerated-X,
...)
- better opportunity for security (though I grant it's not often taken)
- cleaner interaction between applications displaying on the same desktop-- most of the "hacks" won't let applications running in different places share a desktop transparently
For that matter, most desktops released within the last 8 years are so slow and bloaty themselves they can't afford a wire protocol abstraction layer between them and the display driver! Try something truly lightweight, like twm or one of the early incarnations of fvwm with something better than those miserable default configurations, and watch your desktop scream, even with X's supposed weight....when you're writing a game...tweak the difficulty of "Easy" to something [your mother] can cope with. -- onion2k
There are other costs. Encoding/Decoding are the big ones. Context switching is another.
The real question is, if you removed these two sources of inefficiency, what would be the actual speedup in terms of graphics performance. For 3D it was lots, therefore the creation of the DRI to provide direct rendering. For 2D? Best guess is almost no improvement at all; the hardware is not capable of going faster. The only exceptions are bandwidth beasts like video that have been solved in other ways.
If somebody wanted to prove the point they could write DRI/X11 as a complement to DRI/MESA.
Realistically, X11 is pretty fukt. It is horribly slow. Horribly horribly slow. The only thing that makes it usable are the extensions crammed into it. Xv, freetype, Xrender, etc...
Yet we are at an impass. Half of the Unix population loves X for the network transparency, the other half could care less and just want it to draw fast and look nice.
IMHO, we need to ditch XFree completely. Don't ditch the X protocol, just ditch XFree. If we could get a system that supported nice modular drivers, had lightning fast redraws and event handling, and yet still had legacy support for apps using X11, then we'd have something worth using.
Personally, I'm not that impressed by X's network transparency. Sure, I can run an app over the network, but a) I better have all the right fonts; and b) I better hope my system doesn't hang or lose my net connection, because if my system stops responding to all of those X packets, the app on the remote system is killed. I'd be happier to see a clean session detach that could reattached at my leisure. Automatic font transfer would be nice too. Don't have a font installed locally? No problem! I'll just auto install it for your user account.
But, regardless of my bitching, we don't have MagicDisplay(tm) right now. We have X. And being that I use linux as my desktop system, I'm greatful to the XFree team for getting us this far.
I was initially skeptical of Keith Packard's fork but after reading his email, I support it. He addressed the issues that I have been complaining about for years.
KeithP is one of the few people who could make a fork work.
I have a hard time with David Wexelblat who doesn't work on XFree86 and doesn't even believe in it, insulting one of the key developers.
99% is an absurdly high estimate. If you remove network transparency, you destroy X for hundreds of users here who use it every single day.
That being said, I've never used X in a thin-client environment
It doesn't have to be a "thin-client" environment. All you need is a networked environment. At my work we are split about 50/50% UNIX and Windows developers. Windows developers are almost literally tied down to their workstations. That's where their environment is so that's where they have to work. They don't even notice it, because it is so ingrained into their thinking.
On the other hand, I have a Solaris and FreeBSD machine in my cubicle, and I can use them from *anywhere* in the company. In fact, I can use them anywhere in the *world* if I would ever bother signing up for remote access authorization. My cubicle is not my prison. I do a lot of work in the development lab, and it is extremely nice to be able to treat any random workstation there as my own personal environment. I can edit code in XEmacs, peruse its documentation in FrameMaker, check it in with ClearCase, and then move on to the next bug with ClearQuest, all while browing the web and checking my email with Mozilla. This is because of X11. My Windows coworkers can't do that. They're always running back to their cubicles to do their work.
Here's another example. A lot of my coworkers use both UNIX and Windows. They all have KVM switches. I hear they're very popular. But since I don't use Windows, I've never seen the need for one. I can run multiple applications from multiple machines on whatever display I happen to be sitting in front of. Without having to beg IT for permission to buy to the software or hardware to do it.
There are two paradigms at work here. One is the "single user on a single machine running locally." The other is "multiple users on multiple machines running anywhere they want." X11 supports both paradigms. Windows supports only the first. Please don't dumb down X11 to the Windows level.
A Government Is a Body of People, Usually Notably Ungoverned
Off topic, but I can help pointing out couple of things here;
You keep stating that frame-buffer is junk. But if I were Bill or Steve (or any other in charge of technical decisions), I would choose, without hesitation, PDF-based composition engine instead of network-transparancy, because its benefit is way more than that of network-transparency (I prefer ssh and console). Although Apple seems to show off its engine's capability overusing it in all the UI elements, a good example of the benefit is iDVD3 themes which heavily employs transparancy and floating-point based graphics. I will really be suprized and impressed if I see such an app on XFree in NEAR FUTURE. Moreover, I'm not expert at this, but Apple is improve its performance setting the composition engine upon HW accelerated "OpenGL" (Quarts Extream).
It certainly deserves better than 'junk'.
Yes, XFree isn't necessarily slower(despite its unnecesarily large code base and complexity), but is there any reason for it to be significantly faster than, say, that of GDI or Quarts?
XFree has its own strengh, and others do too.
Compatibility at the X layer is overblown, how many people really run apps from so long ago? Sooner or later you need to cut the ties. A new GUI system compatible with QT libs or GTK would be good enough for most people. The people who want to keep using X can, its not like X11 will completely disappear just because focus shifts to something else...
Well it goes back even further than that. KeithP got his wings clipped for a patch he applied right before a feature fix. He may have choosen to "revolt" based on being insulted about being punished, over issues he'd been discussion for a long time. Like most of these splits there is probably a mixture of:
-- genuine differences of opinion regarding direction
-- unclear leadership
-- poor interpersonal issue resolution
In any case if you look at his resume this guy is the kind of guy who should be on an X core team.
So I don't see whether Keith lied or not to be a key issue. His technical issues should stand on there own entirely seperate from whether his tecnique was driven more by anger/hurt or frustration.
I worked for years on dumb X terminals. The environment was
a) tremendously reliable
b) very easy to maintain
c) offered users tons of freedom
Contrast this with your typical Windows corporate setup. Anything other than total lockdown makes the system entirely unmaintainable. As a result user / desktop support ratios are very high and users and constantly frustrated by how little they can do. Virtually every corporation should be running dumb X terminals. It really would cut costs and empower employees.
Take a simple example like software installation. On a Unix system I can safely let users install anything. The apps they install can't run with any more privs then they have and they can't hurt the system.
On windows OTOH letting people use any printer in the building means they have to have permission to install drivers. Letting people install drivers is:
a) hard because they are forced to understand details of printer models
b) allows them to completely muck their system up
Well, what do you imagine would be the alternative to "sending commands over the wire"? X11 and NT do pretty much the same thing when you run them locally.
Under NT, the window system lives in the kernel, and graphics is usually drawn by a co-processor. If you call that "local native API" on Windows, be it for 2D graphics or 3D graphics, it enqueues your request in some buffer somewhere, eventually it switches to the graphics subsystem, the graphics subsystem enqueues the request with the graphics co-processor, and eventually, it gets executed and you probably get an acknowledgement.
Under X11, you call an Xlib function and it enqueues your request somewhere. Eventually, the system switches to the X11 server, which gets the request out of the queue, enqueues it with the graphics co-processor, and eventually it gets executed and you get back an acknowledgement. X11 servers on UNIX/Linux usually happen to use unix-domain sockets as the mechanism by which to get the enqueued requests from the clients to the display server (in addition to shared memory for bulk data transfers); that's because unix domain sockets are pretty much as efficient as you can get for this purpose. If NT had invented some mechanism that was faster (and I don't think it has), one could use that with X11; then, you might connect to maybe "super-duper-comm/:0" as your display, instead of ":0".
Note that if you use "localhost:0" instead of ":0", your X11 server will run much slower, because "localhost:0" really does have to go through parts of the TCP/IP stack. But ":0" really does use a very efficient IPC mechanism.
Now, both X11 and NT, and I mean both, give you some additional hooks (DRI, DirectX) that let user-mode programs ask nicely and get some "direct" access to the hardware. But that is obviously not a tradeoff many non-game programs make, and for good, practical reasons.
Note in particular that for 3D rendering, all of this has been worked out and happens transparently under X11 *:
Basically, X11's capabilities and performance are a superset of those of NT's graphics system: X11 handles the local case as efficiently as NT, using shared memory and "direct" hardware and memory access where possible, but falling back to other communications channels when needed.It's true that this (application) client/server paradigm is tilted heavily toward the idea of centralized servers accessed by smaller clients. And where this topology exists and is necessary, people use X this way and it matters. For average users, it doesn't.
But that's the status quo, and it won't last.
We're going to inevitably move to a distributed computing model, and it only makes sense to do this on a per-application basis as a first step. Almost all the pieces are there. The piece that isn't there is a mechanism that matches slack to need transparently.
In my (years past, not current) daily use of UNIX workstations, I would manually spread my workload around to different boxes just because it made sense to do so. But it was a pain. Imagine if that were automatic and transparent.
In my opinion, X's network transparency will once again become incredibly useful. It's utility just needs to be properly leveraged.
As usual, the people who bitch about X are going to have to find some new reason to bitch about X.
People need to stop complaining about X's fonts. Just use the same TrueType fonts you would use on OS X or Windows (some of them are free as in beer). RTF Font Deuglification HOWTO, for heaven's sake. Open Source fonts are a very, very difficult deal, as fonts need to be coherent from script to script, and have a single artistic vision behind them to be satisfactory.
Quite frankly, the whole stink with XFree86 reminds me very much of ICANN. Technological snobs who won't listen to anyone else, have closed off public participation, aren't transparent, and now are defaming someone who rightly criticizes them. Furthermore, they are blundering. Why should Xfree86 drivers not be modularized? I only have one fucking video card. I don't need to download the drivers for every video-card Xfree86 supports. Xfree86 has also done an atrocious job of integrating the latest drivers from graphics chip corporations, like ATI. Their failure to promptly incorporate these drivers has alienated hardware developers. Why should ATI spend millions of dollars to make drivers for XFree86, if it takes them so long to incorporate them?
The actions of XFree86.org convince me that they want to restrict user choice in the GNU/Linux world, and prevent anyone else from running any X11-implementations other than XFree86. Their refusal to modularize drivers is one thing convincing me of this.
I can not think of any major projects which are as poor as XFree86 in regards to including the community and being accountable to the community. Many of the people within that "organization" are in fact figureheads who don't even believe in XFree86, like one of the founders linked to. If you don't use XFree86 at all, and only use Windows, then imo, you have no business being part of an XFree86 team.
Keith is right to fork off XFree86. He has tried to address his concerns from within the organization, and has been unable to do so. Just like Auerbach. There is only so much one crusader within an organization can do when the rest of the organization is bent on corruption.
XFree86 is proof that even a project covered under a license approved by the OSI and the FSF can be corrupt and non-transparent.
social sciences can never use experience to verify their statemen
It seems to me that all parties involved need to cool down and then come back to the table with a reasonable attitude and work out these issues. Keith has some valid points about the sluggish response of XFree86 development in certain areas, although I disagree with his means of protest. A fork would likely only cause chaos and be detrimental to the cause of unified desktop standards and Open Source acceptance. It is my opinion that there are times when standards and compatibility are far more important than performance and eye candy.
Keith, if you are listening, may I suggest that you formally and thoroughly document your objections to current XFree86 development and provide constructive criticism on how it might be improved? If there are technical complaints, such as relating to performance, perhaps you can write code to prove the need for change.
XFree86 team, if you are listening, may I suggest that a patch tracking feature be added to the official web site? For example, if a patch is submitted to support a new XRender feature but not yet committed to CVS, show this and offer the patch for download right there. As a user, it greatly frustrates me to not have any idea when new features and support will be added and you must admit, the XFree86 release cycle is rather slow. As a user/developer, it would be greatly beneficial to me if I could see precisely where the work is being done. And if extra help is needed in some area, advertise this openly. Relating specifically to driver patches, may I suggest that driver changes be added with far less caution than changes to core libraries? I personally believe that if someone like responsible like ATI submits a patch to support their latest hardware, there is absolutely no need to sit on that patch. Get it out there and get it tested ASAP.
Incidentally, a colleague of mine has done work on VNC for Windows, and it is appallingly difficult. You either have to scrape the framebuffer continuously (kiss performance goodbye), or you have to hook GDI calls to figure out what regions of the screen were updated.
-- ;-)
Kuro5hin.org: where the good times never end.
So instead of one piece of software (XFree86) writing support for detaching and reattaching software, every toolkit should do it? (QT, Motif, Forms, Java, software based on libX11 - libX11 would be the key, I imagine most software uses that) Doesn't sound right to me! Reminds me of software rendering their aa-fonts themselves..
They do say that RANDR-extension should finally give the potential for implementing this capability.
My hardware is a G400 (I like the dual display) and Athlon 1800+. I get virtually identical results. At first I assumed (because a G400 shouldn't be anywhere near a Radeon!) that it was CPU-bound, but then I tried a remote-invocation as well, and got virtually the same results (see below). There's a 100mbit link between the two machines, if that matters...
:0.0
This implies to me that there is a limitation on the number of requests per second that the X-server (irrespective of driver) can do, and that perhaps should be addressed. Either that, or a G400 really is the same speed as radeon 8500... The link to 'tanelorn' is via ssh as well (so it's encrypting and decrypting everything in the protocol stream...)
[simon@atlantis ~]$ x11perf -eschertilerect500
x11perf - X11 performance program, version 1.5
The XFree86 Project, Inc server version 40200000 on
from atlantis.mythology.gornall.net
Sat Mar 22 11:03:29 2003
Sync time adjustment is 0.0537 msecs.
8000 reps @ 0.6795 msec ( 1470.0/sec): 500x500 tiled rectangle (216x208 tile)
8000 reps @ 0.6850 msec ( 1460.0/sec): 500x500 tiled rectangle (216x208 tile)
8000 reps @ 0.6794 msec ( 1470.0/sec): 500x500 tiled rectangle (216x208 tile)
8000 reps @ 0.7947 msec ( 1260.0/sec): 500x500 tiled rectangle (216x208 tile)
8000 reps @ 0.6966 msec ( 1440.0/sec): 500x500 tiled rectangle (216x208 tile)
40000 trep @ 0.7070 msec ( 1410.0/sec): 500x500 tiled rectangle (216x208 tile)
[root@tanelorn denyaccess]# x11perf -eschertilerect500
x11perf - X11 performance program, version 1.5
The XFree86 Project, Inc server version 40200000 on localhost:11.0
from tanelorn.mythology.gornall.net
Sun Mar 23 11:10:28 2003
Sync time adjustment is 1.1608 msecs.
8000 reps @ 0.6954 msec ( 1440.0/sec): 500x500 tiled rectangle (216x208 tile)
8000 reps @ 0.7964 msec ( 1260.0/sec): 500x500 tiled rectangle (216x208 tile)
8000 reps @ 0.6852 msec ( 1460.0/sec): 500x500 tiled rectangle (216x208 tile)
8000 reps @ 0.6833 msec ( 1460.0/sec): 500x500 tiled rectangle (216x208 tile)
8000 reps @ 0.6844 msec ( 1460.0/sec): 500x500 tiled rectangle (216x208 tile)
40000 trep @ 0.7089 msec ( 1410.0/sec): 500x500 tiled rectangle (216x208 tile)
One other thing. I *like* X. I really couldn't live without the network transparency - editing files in co-located facilities via ssh with X-forwarding is just *so* much nicer than using 'vi'...
Simon.
Physicists get Hadrons!
Yeah. FreeBSD, debian are two of the biggest example where core is elected.
It clearly look that, as alan cox said, david have lost contact with X. He is now an open-source advocate, a free software hater (he says that in the thread) and an exclusive windows user.
That beeing said, the motivations for the fork() are not clear either. What I beleive is the problem, is that the XFree core team is overloaded with work because part of the team went working on other things. Young wolfes are pressing them to resign the control of the project, which they are not ready to do.
IMNSHO, they are right. Slow dev is better than fast and loose. Wanabees generally think that can do the right thing, without understanding that managing people (because core is about mangement) and driving a project is hard. And the more people commit, the harder it is.
This thread is really exciting with lots of agression being worked out. I need to point out that XFree86 has been really fabulous for me. I have used Linux since 95 (Caldera, Redhat, now Suse) and I could not be as productive as I am without it. I have never had a problem with the windows. (I use KDE). I read my mail (kmail), browse the web (Mozilla/Konqueror). But mostly I use xterm/kconsole. I may not be in a majority, but I am one of a sizable number of users (English speaking) who don't experience any of the problems described in this thread. I don't want to go on, but You guys have done a fantastic job. Work it out. As dogbert would say, 'try to separate the personality from the problem'.
Given that so many popular widget sets / window managers / desktop themes do like to stick shading and bitmaps on everything, and that many users think this looks kewl, and that in any case Mac OS X and other systems seem to exploit the video card's hardware to do this stuff quickly, wouldn't it make sense to fix the X protocol so that such eye candy can be displayed without slowing the system down too much?
-- Ed Avis ed@membled.com
I agree. In my previous job my main working machine was a Win2k box with PuTTY and a commercial X server installed. It's actually a very nice environment to work in -- I could use Explorer to administer and manage files on my remote linux server, editing PHP code with my favourite Win text editor (ConTEXT) and at the same time using Outlook (not my fave, but the company standard), and develop Win32 code. Best of both worlds. Plus I got to wow all my surrounding Windoze-only colleagues with impressive looking KDE themes!
Without X's network transparency, I'd be upstairs on the linux box half the time, separated from colleagues, and reducing my efficiency.
The only downside -- having to walk upstairs to change CDs occasionally!
However, I also see the need for a slimmer, leaner, meaner X, with a fast (perhaps even kernel-level?) direct rendering system, with less cruft. I have a lowly PIII 550 256Mb at home, and X is a bit of a pig; whereas Win2K's GUI just whizzes along nicely.
I don't necessarily think that network transparency + a fast GUI are mutually exclusive. Surely it's possible to come up with a high-speed rendering and input API that could be controlled remotely via a swappable
I can envisage something like an OpenGL-like pipeline, with a serialised command input, that could be streamed to a specialised hardware accelerated layer on the local machine, or via network to a remote display server? The remote server could afford to be quite minimal in this scenario - a glorified video driver with support for input devices. Surely most of the code necessary for a prototype of this system is already out there?
I know this. It's a feature -- who wants to look at blurry fonts all the time? But your post doesn't change the fact that AA fonts under Windows do not seem to impact the general responsiveness of the system. So why should they do so under X?
;-)
If my display hardware can shunt polygons and surfaces around with hardware alpha channels, bi- and tri-linear filtering, and my cpu is capable of rotozooming entire screenfuls of pixels with bilinear filtering, then I think it can probably cope with a few anti-aliased fonts. Especially as there are so many clever tricks that can be used to accelerate this process.
To highlight this point, I am posting this message using 600% zoom using Opera under Win32
- Politics: The group is closed and controlled from topside the way old companies do things.
- Tech Vision: XFree's top ppl are wishing to move away from what makes X interesting and follow what has been popular and easier to do (yes, it has also been faster).
This group should be split. I only hope that they come back together or that ideas merge. Perhaps the X group will become more open in the future.I prefer the "u" in honour as it seems to be missing these days.
I've noticed that the Sun developers are trying to use this moment of discord to get STSF reconsidered. However, STSF is junk. Even if it were not junk, Xft has already been adopted as the font engine for X. Trying to replace it now with something that's much more complex (and doesn't do anything more useful) makes no sense whatsoever.
I don't agree with the people who say that X is bloated, lacks performance, and cannot be fixed, so we need to throw it out and start over. But if STSF were added to it then it WOULD be time to take it out back and put a bullet in it. In many situations the current versions of STSF can reduce text processing to a snail's pace.