Slashdot Mirror

http://www.fresco.org/news.html

Not Found

The requested URL /news.html was not found on this server.

Sad.

I don't know how X.org is doing these days in terms of progress. The Fresco project appears to be dead.

Does anyone know anything about GGI? Do they have a handle on this concept?

http://www.ggi-project.org/

I for one am still waiting patiently for Berlin (now called Fresco) to replace X. It should be amazing when it is finally finished!

Berlin apparently became Fresco http://www.fresco.org/ and haven't had any visible development since 2004. Last release was 2003.

Sure, they might be able to draw vector graphics, just like any system, by rasterizing them and then sending them to the output (I am not too well versed in this stuff) or having the canvas rasterize it for X. I think Fresco would keep graphics as vector for a longer period, making resizing to different screens easier. However, it dosen't seem to be very active, as the status page is down, and the wiki was closed due to vandalism.

This article is nothing but a hatchet job on a mature committee standard. Corba is not falling like DCOM, it's soaring like the Hindenburg.

You're describing Fresco, formerly Berlin, and Fresco before that and Interviews even further before. Somehow it didn't catch on under any of those names. What a shame.

Or was that Fresco?

Either way, the website hasn't been touched in two years...

Yeah wasn't there a Y windows in the works at one point.

You mean this?
Fresco was the other big contender.

The Linux Kernel is so flexable in how you can customize it for the hardware situation, its a shame you can't do the same thing for X.

Modern X actually does let you plug-in, plug-out all kinds of useless^H useful crap. It has actually matured into a fairly decent system, network transparency or no.

Where this article falls flat is on trying to make us believe that any of what we're seeing is "new". We've seen it all before, just with fewer cheap effects (e.g. the "wobbly windows").

On the off chance you're not trolling.

Cairo != Berlin == Fresco.

Berlin, to which you refer, became fresco which doesn't appear to have had any updates since 2003. I think we can call that mostly dead. Berlin/Fresco was supposed to replace X with something entirely new.

Cairo is something entirely different and runs on top of X11. It is simply a new rendering model for on screen drawing. Think of it as being akin to DisplayPostscript or Aqua: instead of addressing the screen in terms of pixels it addresses it in terms of regions, paths, fills, etc. The model is based on SVG. Cairo isn't restrcted to X11 however, it can run on top of a variety of display systems including Aqua, OpenGL, and Win32. Think of it as a cross platform rendering abstraction if you like. If GTK adds the ability to render to Cairo then GTK/Cairo will automatically work on all the listed platforms (rather than requiring separate Aqua and Win32 ports of GTK).

Jedidiah.

Then you want Fresco.

Yes, because there's nothing quite like using an alpha-level project that hasn't had a nightly snapshot update in a year (last snapshot is from February 8, 2004). Certainly instills confidence in the project, if you ask me!

Then you want Fresco.

Even has pretty screenshots.

Compatibile with GGI and X for your old applications.

There is this little thing called a network effect, though.. which means you run X because everyone else runs X, and nobody wants to be the first guy to try something new. So good luck getting it adopted.

Then you want Fresco.

Even has pretty screenshots.

Compatibile with GGI and X for your old applications.

There is this little thing called a network effect, though.. which means you run X because everyone else runs X, and nobody wants to be the first guy to try something new. So good luck getting it adopted.

Have you used previous versions of X11 before 2001?

Yes, though it was mostly Sun's X server that I was using back then. Hell, I remember using X in the early 90s. There are a lot of different implementations, some better than others. XFree86 really stagnated a bit a while ago, but things are moving again with Xorg.

THere has been talk several years ago about the Berlin project which was going to be a replacement for X and would be moddeled after Apple's aqua. Unfortunately it was written in an obscure langauge called Forth so no one knew how to work on it. THe project was abandoned.

It wasn't abandoned. I am not sure what gave you that idea. It was, however, renamed to Fresco, and is still in development. I followed Berlin development since about 1998. It has been very slow, but the concept is nice. I doubt it will ever become mainstream. Far more likely is improvements to existing X implementations, and new and better extensions (see Keith Packard's latest work).

Win32 GDI as buggy as it is can run on a 486 with 8 megs of ram. Can Xfree86 do that?

Yes, I believe it can.

Jedidiah.

Likewise, an opensource driver can be ported to other architectures (eg PowerPC, Sparc, AMD64) or major kernel updates (with driver ABI changes). For binary drivers, you need the good will of the hardware maker.

So for me at least binary only drivers are always a problem. I want opensource (or free, i.e. libre) software.

The X developers should rewrite the server from scratch using the Aspect Oriented methodology and for example the AspectJ programming language. Many of the X extensions really touch all parts of the server which is exactly the kind of problem aspect oriented programming was designed to solve.

Using AspectJ, an extension such as the Damage extension could be written in a weekend.

Also rewriting the server in AspectJ would allow the developers to leverage the full power of the Java language. With Java reflection the core dispatch code in the server could be replaced by just a few lines of code. The RENDER extension could be completely removed from the server and replaced by using the delegate design pattern to forward X requests to Java2D

The Fresco project had huge potential, but never managed to escape the legacy language C++. It seems everybody working on window system is stuck in the software engineering practices of the seventies.

I must say I still prefer the idea of a "heavy" windowing system/manager, mainly for the benefits it gives to network transparency. For example, imagine several clients connecting from several different machines and/or user accounts. Under X11 with GTK+/QT/whatever, the different widget sets appear differently, and can appear differently depending on user settings. I like the sound of Fresco - all widgets are rendered by the server. Under this sort of system the differences between GTK+, QT, etc would simply be in API, not appearance.

I like your bringing up of HTML and the use of onclick, etc Javascript events. I'd like to take it one step further: perhaps an application or widget set could send small scripts to the windowing system to handle simple local events.

For example, the app puts up a dialog with a number of text entry boxes, buttons, and perhaps a graphic (a preview perhaps). Along with the basic widgets, it also sends to the window server a set of event handlers written in some scripting language (lisp, postscript, javascript, python...). These event handlers then control how these widgets interact without bothering the app/widget set running on the client machine. The user can fiddle with buttons and stuff, only needing actual client-server interaction when the preview needs to be updated or when the user hits the [OK] button.

So these scripts would handle the little interactions with the low-level widgets. They would allow the widgets themselves to be rather simple. The applications and/or widget sets would provide scripted event handlers to customize their exact behaviour. In this way, the set of "fixed" widgets in the windowing system could still remain flexible without becoming too complex. And like another poster said, GUI's are mostly "done" right now. Assemble the most common and unique widgets in the server, and let client-side widget sets customize them with a server-side scripting language.

what about fresco?

ok, ok, i know it's nowhere near done, i just wanted to open some discussion on it

Read this thread:
Fresco Problems
Looks like they are far from a usable system

So why is it going to succeed where these failed? :
fresco
YAX (Y Ain't X)
The Y Window System
Oh never mind. What's the point?

Reading this YADAX (yet another discussion about X) here and problems with same, I remembered that a while ago a bunch of people set out to write a replacement, first called "Berlin", later Fresco. But the "latest news" on their web page is about ten months old. Is Fresco dead or just resting after a prolonged squawk?

Reading this YADAX (yet another discussion about X) here and problems with same, I remembered that a while ago a bunch of people set out to write a replacement, first called "Berlin", later Fresco. But the "latest news" on their web page is about ten months old. Is Fresco dead or just resting after a prolonged squawk?

fresco?

Fresco is developed with such monitors in mind: You give sizes in mm and it will adjust it to the screen. So your windows will stay the same size on such huge monitors or more modestly sized ones. Of course you can just adjust the zoom factor with which the window is rendered if it was designed to be too small or too big...

Downside: Fresco is far from useable and it will break X compatibility till someone writes a compatibility layer (like Apple did for their MacOSX). It is the most interessting GUI project in the free software world though, so help to get it working!

I'm not talking about toolkit competion on top of X - that's somewhat a bad thing, because there's tons of repetition of effort, and the end result is inconsistency. That X allows this is its major shortcoming. I'm also not talking about eliminating X's network transparency - that's its best aspect, and must be preserved at all cost.

I want something with server-side widget rendering. This should be plugable and themeable, so their could still be competition. But since clients would communicate on the level of "put a button here" instead of "draw a grey rectangle with text here," it would be easy for all the programs on a display to have a consistent UI. There are some attempts to do this, PicoGUI and Fresco, but I want them to become popular, to compete, and to retain X compatibility (by having clients which are rootless X servers). It would take a few years, but the Linux status quo could move to something better than X, and we'd win in the long run.

(yeah, I suck) Fresco.

Where have I seen this idea before? Oh yeah... "Berlin", now being called "Fresco"...

I saw a demo of this at the "Alternative: Linux" conference in Montreal in late 1999, and it seemed "almost done" then. Haven't heard a whit about it since then.

I can't see why either of these projects would get the necessary 'traction' to have much meaning to the world, even if they ever do finally get the technology finished. Though I do like cool new technology. :-)

Cheers,
Richard
(RichDice username, ID 7000+random... I forget now)

I know this didn't make it to the front page, but is there really this little interest in embedded Linux, or non-X11 GUI systems?

I for one can't say I've ever really been too excited about MicroWindows or this PIXIL system built on top of it. We've not seen any PDAs that use it, although the Royal Linux PDA was supposed to use PIXIL/MW, it never saw the light of day.

X11 is entrenched. There have been a number of free alternatives for a long time:PicoGUI, MicroWindows (w/ NanoX [X11 API emulation] or PIXIL apps), Qt/Embedded, DirectFB w/ GTK+, Squeak (and on top of it, Dynapad), W Window System, Berlin/Fresco Window System, MGR and others. Many of these have been around for 10 years or more.

Yet, what does almost everyone use on Linux or Unix? X. Relative to the X11 install base, there is a miniscule minority of folks using Qt/Embedded + Qtopia on their PDAs, but even so it still a crappy solution when you consider how poorly Qt/E is suited to PDAs.

About as many Zaurus users are using Squeak as a windowing system. Perhaps more using Squeak, not sure. They may not use it as a X11 replacement, but they're using it all the same.

PicoGUI is the bomb. Although, it sounds like it may be going dormant for a while. One of the most promising of non-X11 windowing systems out there, but still no one uses it.

When will we have a project like this that really goes somewhere? Anyone have any bets?

People are trying, see Fresco and E17's Evas

Wheee, I thought Fresco (fka Berlin) had had trouble. ;)

While this may be good news for Cairo) and Fresco, in giving them more time, it may also indicate something else, that Microsoft found out that the hardware is not and will not be good enough (even if I doubt that idea).

These are trying to make a difference:
Directfb, Cairo , Fresco and PicoGUI

The discussion about framebuffering was on the XFree86 open discussion mailing list last month.

Judging from the Fresco-changes list, progress continues to be made, albeit slowly. They really could use some support. If you know C++, check it out, it is an interesting project.

Every time the discussion about replacing X comes up, somebody mentions Fresco (formerly named "Berlin"). However, I haven't heard anything for a long time about that project, and the last news is from March. Anybody know what happened? Our are they just hacking away so hard that they don't have time to update the webpage...

Every time the discussion about replacing X comes up, somebody mentions Fresco (formerly named "Berlin"). However, I haven't heard anything for a long time about that project, and the last news is from March. Anybody know what happened? Our are they just hacking away so hard that they don't have time to update the webpage...

Software does need to have a catchy name. Fresco/a>, for instance, is much more attractive than the topic of this article. Just because of its name.

Interesting, I'll have a closer look at this later and it reminded me of the Berlin project (renamed to Fresco).

This is why we need a resolution indepentent windowing system (like Fresco, formerly Berlin, is). It makes zero sense for an increase in resolution to mean a decrease in font size. Stupidly, everything is measured in pixels...

Fresco is about this, and I think that this would be an excellent solution. After all, I'm pretty sure that something like that could actually run over my modem, and still have enough bandwidth to look at /. :)

Cheers,

Michael

The primary, essential IPC (inter-process communication) mechanism X uses is the socket. If the client and server are on the same machine, they can use local (aka Unix domain) sockets, which are typically very efficient. Over an IP network, they use TCP sockets. Other encapsulations exist as well, such as DECnet. Since the socket is the basis for the X protocol, it is inherently less tied to a particular operating system or type of machine than most windowing systems.

Your first and second wishlist points are goals of Fresco, which is a very interesting project and will be useful if it ever gets any applications.

Check out the Freesco windowing system. It does exactly this, plus more.

Isn't that what Fresco is supposed to become?

Not quite there yet, but it is a start.

Check out Fresco

Having the 'screen' like functionality of RDP/VNC where running where applications continue to run in the event of an interruption, but have application windows interleave with other windows rather than be kept in separate 'desktop' windows.
There is xmove, which is basically screen(1) for X.

A completely new project to make a somewhat X-like system with more useful primitives. The native network protocol need not be X compatible, but an application running on *top* of it could provide X compatibility.
Sounds like Fresco.

Sounds a lot like Fresco.

As for now, I'll stick with xp and fluxbox. And OSX when I save the money for a mac heh. However, I'll continue to support directFB and fresco over XFree86 just so that the projects get the much deserved attention that is essential to their success. Lets hope I wont have to install XFree86 in five years time to get a decent desktop under *nix.

And btw, fresco can (/ hopefully will) coexist with DirectFB. Also, using the fb (that penguin logo on bootup) is slower than pure console - check /usr/src/linux/Documentation/fb/vesafb.txt "graphic mode is slower than text mode."

DirectFB still has a lot of questions to answer. AFAIK there is still not window management protocol for instance - X11 provides a lot of things most people don't think about, DirectFB would have to provide equivalents first.

Something like.. Fresco.

Just as Linux, BSD, SCO and a few others all provide implementations of (more or less) the "UNIX" specification on i386 hardware, there are multiple implementations of the X11R6 standard on i386-based unixes.

If you don't like XFree86, the folks at XiG would be happy to sell you a copy of AccelX. MetroLink systems still offers Metro-X (which was the bomb back in the RedHat 4 days...dunno about now), and if you don't have any money to spend, you can still download, compile and use the honest-to-god MIT/XConsortium X11R6.6 server.

If you want a windowing system that's not based on X11, your options are a bit more slender, but they're there. The Fresco project (formerly "Berlin") looks promising, as does PicoGui.

Time for Fresco?