The BeOS is based on the ideas that "One processor per person is not enough," (Jean-Louis Gassee) and that it is foolish for a modern operating system to incorperate a lot of legacy code. The BeOS was written from the ground up by Be, Inc. It is much more efficient than most current OS's because it does not make any sacrifices to backwards compatibility. It also supports most major modern operating system concepts. There are currently releases available for PowerPC and Intel platforms.

Anyone who has any curiosity about Operating Systems at all should really give BeOS a try. It has some wonderful features that really don't exist in any other operating system, going to show that there is plenty of room for improvement in the OS world today. Unfortunately, however, you'll find that there isn't nearly enough mindshare, and consequently not enough applications, drivers, or support to switch to it full-time under most circumstances.

BeOS is based on a microkernel architecture, meaning that the kernel only has the bare-bones services that must exist in kernel space. The kernel provides a hardware abstraction layer and other basic services, but most of the functionality is provides in the various servers which run in user space. Sound, networking, and graphics services all are implemented through the use of these servers, which allows them to be stopped and restarted without rebooting! Also, if one of them crashes, it doesn't take the system down with it: you just restart whatever server crashed, and you're on your way.

Not that a reboot is so painful. BeOS boots extremely quickly, and there's never time spent waiting for an fsck, thanks to the journaling of BFS.

The next thing you notice as a user is how ridiculously responsive the GUI is. X11 and Windows simply don't compare in this department. I run it on a PII-300, 64 MB RAM, and GUI operations seem instantaneous. Resizing windows, switching between virtual desktops, clicking on buttons, it's all lightning fast, and doesn't slow down even if the computer's under a heavy load. It's nice to be reminded that GUI's don't have to feel clunky.

It looks good too. Really good. Fonts are anti-aliased, and look better than any other GUI, easily. It supports alpha blending natively, so if you drag an icon around, on top of other things, you see the background through the icon. But like the rest of the GUI, it's all very fast.

While the GUI is wonderful, with BeOS you don't have to give up your command line either! It ships with bash, gcc, grep, vi, perl and friends, making old UNIX heads feel right at home. Though it doesn't come with everything you'd expect from a UNIX commandline (awk, autoconf, and others), you can download ports of most of the GNU tools to supplement the ones that it comes with. And since BeOS includes a fairly complete layer of POSIX compatibility, porting apps from UNIX is not too difficult.

Not only do you get a commandline, but also a very powerful scripting engine for GUI applications called "hey." To demonstrate:

$ hey Tracker get Title of Window [0]
(Tracker is the equivalent of the Finder on MacOS). Or maybe something like:
$ hey StyledEdit set Frame of Window  to "BRect(107,76,607,476)"
As you can see, hey is very powerful.

Programming for BeOS is an unparalleled delight. The API is a clean set of C++ classes that work the way you expect them to. After programming on BeOS, going back to MFC is excruciatingly painful. Just to demonstrate, the "Hello world" app in BeOS looks like this:

//
// Hello World 2000
//
// Copyright 1998, Be Incorporated
//
// Written by: Eric Shepherd
//

#include <Application.h>
#include <Window.h>
#include <View.h>


//
// HelloView class
//
// This class defines the view in which the "Hello World"
// message will be drawn.
//
class HelloView : public BView {
    public:
                        HelloView(BRect frame);
        virtual void    Draw(BRect updateRect);
};


//
// HelloView::HelloView
//
// Constructs the view we'll be drawing in.
// As you see, it doesn't do much.
//
HelloView::HelloView(BRect frame)
            : BView(frame, "HelloView", B_FOLLOW_ALL_SIDES, B_WILL_DRAW) {
}


//
// HelloView::Draw
//
// This function is called whenever our view
// needs to be redrawn.  This happens only because
// we specified B_WILL_DRAW for the flags when
// we created the view (see the constructor).
//
// The updateRect is the rectangle that needs to be
// redrawn.  We're ignoring it, but you can use it to
// speed up your refreshes for more complex programs.
//
void HelloView::Draw(BRect updateRect) {
    MovePenTo(BPoint(20,75));            // Move pen
    DrawString("Hello, world!");
}


//
// HelloWindow class
//
// This class defines the hello world window.
//
class HelloWindow : public BWindow {
    public:
                        HelloWindow(BRect frame);
        virtual bool    QuitRequested();
};


//
// HelloWindow::HelloWindow
//
// Constructs the window we'll be drawing into.
//
HelloWindow::HelloWindow(BRect frame)
            : BWindow(frame, "Hello World", B_TITLED_WINDOW,

    B_NOT_RESIZABLE|B_NOT_ZOOMABLE) {
    AddChild(new HelloView(Bounds()));
    Show();
}


//
// HelloWindow::QuitRequested
//
// When the window is closed (either by the user clicking
// the close box or by some other means),
// this function is called.  You can add code to this
// to give the user the opportunity to save their document,
// or perform other such activities.
//
// Here we just give permission to close the window.
//
bool HelloWindow::QuitRequested() {
    be_app->PostMessage(B_QUIT_REQUESTED);
    return true;
}


//
// HelloApp class
//
// This class, derived from BApplication, defines the
// Hello World application itself.
//
class HelloApp : public BApplication {
    public:
                        HelloApp();

    private:
        HelloWindow        *theWindow;
};


//
// HelloApp::HelloApp
//
// The constructor for the HelloApp class.  This
// will create our window.
//
HelloApp::HelloApp()
            : BApplication("application/x-vnd.Be-HelloWorld") {
    BRect windowRect;

    windowRect.Set(50,50,200,200);
    theWindow = new HelloWindow(windowRect);
}


//
// main
//
// The main() function's only real job in a basic BeOS
// application is to create the BApplication object,
// run it, and delete it when it terminates.
//
void main(void) {
    HelloApp *theApp;        // Pointer to our application object
    theApp = new(HelloApp);
    theApp->Run();
    delete theApp;
}

As you can see, there are no silly AFX_MESSAGE_MAPs, nor funny typedefs--this is C++ at it's best.

BeOS 5 for Intel, their latest release, is available for free, for non-commercial use. You can download it from http://free.be.com--the entire OS, including many sample applications and demos is 40 MB! All the development tools, available for free as well, are another 20 MB. The OS download is actually an EXE that installs a 500 MB file onto a Windows partition, which is nothing but an image of a BFS file system. Then, in a procedure I don't really understand, it somehow manages to boot BeOS completely natively (ie. not "under" windows). However, once the OS is installed, you can use the included Disk utility to create a real bona-fide BFS partition and install from the 500 MB fake partition to the real partition. I know this can be done: I've done it.

In my opinion, BeOS is the best desktop operating system out there. While Linux and other Unices shine on the server side, BeOS excels on the desktop in ways that UNIX can never really do if it is to maintain its flexibility.

But I fear that without major vendor support, BeOS is doomed to parallel the Amiga; superior as it is in some ways, it just doesn't have the momentum to overcome the formidable barriers to entry in the OS market.

Sources:
BeOS Bible: Scripting - http://www.beosbible.com/bos/ch_scripting6.html
http://shell.2xtreme.net/~dirk/BeOS/workshops/lesson1.html

I agree that BeOS is a great operating system. But what I find unnerving is the fact that the supported hardware is even more limited than it was with Linux in the old days of 1.1.12...

A long time BeOS only had two supported NICs. One standard NE2000 and the other was the 3Com Etherlink.
Absolutely no support for 100Mbit networks.
Even cards, such as the Realtek 8029, which are PNP Versions of the NE2000 did not work. The PNP Part of the OS couldn't activate these devices, although there was no problem configuring the SoundBlaster AWE 64...

By now, there is a third-party driver for the Realtek 8139, one of the better 100Mbit NICs.
The saying may be, better late than never, but this time it was one and a half year too late... Maybe I will take again a look at BeOS 6.0, but with 4.5 and 5 I weren't overly impressed. Okay, the desktop looks very nice and it was very stable and the CLI is a stripped down version of BASH thus I'm feeling comfortable but a computer without networking is no computer to me.

To those that say "BeOS is not as good as linux", I don't see the logic in comparing apples to oranges. Linux was never meant to be a desktop operating system, and indeed it's struggling to fill that gap. BeOS is good at what it's designed to be, which is a GUI-based desktop OS. Its graphics are impressive, and it can handle up to eight processors simultaneously. In fact, http://www.benews.com/story/1875 WOULD HAVE led you to some screen shots of said 8-way PIII 550MHz running 25 AVIs simultaneously, but the article is old, and the images have been removed. Nevertheless, you still ought to read the article. Be is impressive, and it is only getting better. The largest problem I have with it is that they are currently 'faking' a multiuser filesystem. I mean come on, why are full -rwxrwxrwx even necessary in an OS that doesn't (yet) support multiple users? I play with the perms sometimes when I get bored, chmod'ing them all to 700 or even 000. I find BeOS' baron user to be a nice change from always having to see root in some "other" OS'es.

For those that like BeOS, I personally like QNX more. It's microkernel based, yet fully POSIX compliant. Most things that work in a *ux distro will work in QNX. Now I remember QNX from it's demo disk days, and I never imagined it would go so far. The native QNX GUI is rather underwhelming, but it can run X just as easily. Even better, unlike BeOS, it has a true CLI instead of being totally GUI based. Of course, you can learn more about it at http://www.qnx.com
What has stopped me currently from actually buying the Pro version of Be is the fact that it has a very small user base. But, they are some of the most loyal users I've ever seen on any operation system. Like on Linux and other open-sourced OS's they write and post their own programs, which can be found on websites like bebits.com. In addition, the programs rarely ever surpass the 1 mb level, unless, of course, you're downloading an office suite. No, it has little multi-user support, but go ahead and try to crash the thing.

What keeps me holding out is unconfirmed rumors that Be, Inc, is planning to open-source BeOS. This has raised speculation from many industry analysts that, should Be become a free OS, it will become the choice of less experienced users, instead of the ultra hands-on Linux.

In response to SluggoSlacker's writeup:

BeOS will not and cannot be open-sourced. The rumors are unconfirmed because they are completely false. The reason BeOS is closed is because there is a lot of proprietary code in there, which is not owned by Be. Without this code, the OS would basically be useless. Look in the About BeOS window sometime. MP3 support by Fraunhofer, RSA encryption by RSA, USB support by Intel, and Indeo video by Intel. That's just the major stuff, there's a lot more "under the hood". While it might be nice for some people to think about, most Be zealots like myself can't bear the thought of BeOS becoming like Linux, with 12 billion different versions, or worse yet getting absorbed by it. Not that there's anything wrong with Linux, it's just that the two operating systems are geared for totally different things, Linux for running servers, BeOS for creating multimedia.

There are parts of the OS that are open-source right now, though. The source to all the GNU utilities that Be uses is on the Be CD, the Tracker and Deskbar are open-source (with, I think, a BSD-ish license), and the code to a few of their demos comes with the development tools.

As of today (April 2002), Be, Inc. is in a process of dissolution. All Intellectual Property, including BeOS source code, has been sold to Palm for a ridiculous $11M. They don't want to market it though, it seems they just wanted all the engineers to come over.

BeOS is simply the most incredible operating system I've ever used. The interface is beautiful and well-designed, programs are responsive and snappy, it boots insanely fast, it comes with a command line, etc. etc. Unfortunately, it was never very popular, and as such it did not have the driver support or number of applications necessary to make it practical for everyday use. Which is a shame, because BeOS had one of the nicest programming APIs out there. BeOS Personal Edition came with a few applications, including Media Player and the NetPositive web browser. Like the OS itself, most Be applications are very clean, simple, fast, and responsive. The NetPositive browser it starting to show its age, although it is still quite a capable browser. However, people wanting a more up to date browsing experience should have a look at BeZilla (www.bezilla.org), a port of the Mozilla browser to Be. BeZilla tends to be somewhat buggier than equivalent versions of Mozilla on more common platforms, though it has kept up well.

Sadly, Be Inc. is no longer in business. Going against Microsoft in the x86 desktop market proved to be too much, and after a short excursion into the Internet Appliances market with BeIA, Be was purchased by Palm, Inc. Even the www.be.com domain is now up for sale, and what remains of the company web site is now located at www.beincorporated.com. However, it seems that many of the fine engineers from Be are now working on PalmOS 6. Hopefully we'll see some of the revolutionary ideas from BeOS show up in newer handhelds and PDAs.

For those who wish to try out the BeOS, versions of Personal Edition are still available for download, although not from Be's site. The latest official release was 5.0.3, although there was an unofficial release called "Dano" with was supposedly based on leaked beta code and includes a number of additional utilities. A number of development efforts have started since the Be buyout to create an open-source BeOS clone. Some of these include Blue Eyed OS and OpenBeOS. Another OS similar in concept to BeOS is AtheOS. Recently Bill Hayden created a fork of AtheOS with APIs to match that of the BeOS. Whatever happens with these development efforts, it's always nice to boot up BeOS once in a while and see what OSes could, and should be like.

Log in or register to write something here or to contact authors.