ReactOS Runs On The XBox

KJK::Hyperion writes "ReactOS (the open-source Windows clone) has been ported and successfully runs on the Microsoft XBox (screenshot), thanks to the interest and knowledge base of the XBox Linux project and the work of Gé van Geldorp (HAL and boot loader) and Hervé Poussineau (FATX driver)." (Read on for more.)

KJK::Hyperion continues "This port definitely establishes two facts: the XBox is nothing but a broken PC, and the kernel + HAL design that ReactOS inherited from Windows is sound - all of the changes to the core system necessary for the XBox port (namely, the blacklisting of a buggy PCI device and handling the fixed partition table on the built-in hard disk) were limited to the HAL. This is a first, important step towards better portability, as it has already underlined some shortcomings in our build system.

What the port is lacking is hardware support: especially, ReactOS has no USB support at the moment, so it basically just sits there being pretty, because mouse and keyboard won't work. The network and video cards should be mostly identical to their "real" counterparts, so the Windows drivers for them should work (except the video card, a modified GeForce - it's been established we need some HAL trickery to make the Windows driver load). We wouldn't mind some help :-)

To run ReactOS on the XBox you need our custom version of the Cromwell boot loader (not released yet) and the XBox HAL for for ReactOS."

Comments

Yeah...

[bccomm]

but will it run Linux?

Oh wait...

Next question:

[Anonymous Coward]

When will they get ReactOS working on a PC?

Minesweeper

[believekevin]

Does Minesweeper support Xbox Live?

Yeah...

[Anonymous Coward]

My ISP won't talk to me after lodging a support call for helping gettting ADSL hooked up to a WinXP install running under VMWare under Linux on my XBox.

Re:ReactOS?

[KJKHyperion]

ReactOS is Wine - everything Wine has, ReactOS has too, except the Linux-specific parts (that, in ReactOS, will be handled by drivers). And ReactOS does implement recent APIs, we're no way stuck with Windows NT 4 compatibility, in fact our current baseline is more like Windows 2000 (especially true for the kernel). Finally, we won't just get up one day and declare 1.0: it will be 1.0 when compatibility reaches the intended milestone for 1.0 (namely, good enough to replace somewhere between Windows NT 4 Workstation and Windows 2000 Professional)

Re:ReactOS?

[k98sven]

I'm impressed by what they've done so far, but not the seven years it took them to do it.

Well, this is a bit symptomatic of a lot of OSS projects, they start out with a grand vision and end up planning and then re-planning and throwing out code and never really get off the ground. Some die and stay dead, some get picked up by a group of enthusiasts with a more down-to-earth approach of 'Getting something working now, improvements later.' and the project takes off.
(Case study: See Linux vs. GNU Hurd)

I believe this is pretty much what happened with ReactOS (I'm not a ReactOS developer), so I wouldn't hold it against the current crowd too much.

I suspect it will have the same trouble WINE runs into: it's chasing a moving target, and it's way behind.

Ah, the old catch-up argument. It's a valid argument, but it's not as important for API:s as it is for, say, file formats.
With the MS Word file format, Microsoft can tweak and alter that all they want, because it's not publicly documented, and they're not that interested in having compatibility with anything other than MS own products. Backwards compatibility isn't important. Heck, they're happy to break it and create incentive for people to buy the new versions. That's a hard act to follow.

With API:s, things are quite different though. Firstly, the '80-20 rule of features' pretty much applies. Most programs don't use the entire API, but a rather small subset.

Secondly, API:s rarely break backwards compatibility. That would break all existing third-party apps and make it difficult for people to migrate. The exact opposite situation to the previous one. So MS bends over backwards to make stuff backwards compatible. Windows 3.0 apps still run on XP.

The APIs are also (relatively) well documented. Sure, there's a lot of undocumented functionality, but most of that is also unused. The implementer has access to the same information as most application-developers.

Another point of difference is that you don't have to be super-fast in implementing new API:s.
The day a new Word version hits the street, people will be asking 'Why doesn't this work with OpenOffice?'.

Not as true for APIs. While we all like the latest and greatest, professional developers don't rewrite their programs to use the latest APIs 'just for the heck of it'. There has to be good reason. In fact, you want to avoid using the latest APIs as far as practical and economical, because otherwise, you're going to be shutting-out potential customers running the old OS version.
(There are plenty of brand-new apps released today which run on Win98, or Win95 even.)

Re:ReactOS?

[AstroDrabb]

I'm impressed by what they've done so far, but not the seven years it took them to do it

Your kidding right? How many OS's have you developed yourself? None? I thought so. MS spent millions and took _many_ years to develop the NT OS, and _many_ more years to get it stable (NT 4 sucked for stability, 2k and 2003 still crash, though not as much as NT 4)

Here is a group of OSS developers working in their _spare_ time and you say your not impressed? Dude, your an idiot. This small group has done what MS did in _half_ the time. I am _very_ impressed.

I guess your expecting a small group of developers to duplicate what a bunch of developers and tons of cash did over _years_ funded by the _largest_ software company in the world?

Re:ReactOS?

[k98sven]

Oh please. I didn't say "Windows is backwards compatible with every single app".

I said that Microsoft tries hard to keep backwards-compatibility.

But don't take my word for it, I don't work for them. Read Raymond Chen's various blog articles on the subject. He is one of the poor souls at MS who worked his butt off to try and keep backwards-compatibility.

Re:Uh huh.

[Erwos]

That's like saying an AthlonXP emulates a Pentium4. It's reimplementing something, not emulating it.

-Erwos

Re:ReactOS?

[KJKHyperion]

I believe this is pretty much what happened with ReactOS (I'm not a ReactOS developer), so I wouldn't hold it against the current crowd too much.

ReactOS was born in dark, barbaric times. In 1997, your most realistic option to build PE executables with GCC on Windows was DJGPP, the port of GCC to a DOS extender, because MinGW didn't exist yet. I have had the dubious privilege of trying that - when I joined the project, DJGPP was no longer required for the main tree, but the boot loader still had to be built with it.

Also, the "don't design, code!" attitude worked in the beginning, to get anything done and avoid the mistake of the ReactOS father, FreeWin95, forever stuck in the design phase, but it backfired when real stuff began to run. It just doesn't work when cloning a system as firmly established as Windows - you can't always attack the problems by implementing function after function, many times you need a good overhead view. The short of it is that we have some embarassingly bad code in the kernel.

Comment removed

[account_deleted]

Comment removed based on user account deletion

Re:Hmm Running a..

[WJMoore]

...where is the slashdot article for reactos?

That would be here:
ReactOS 0.2.3 Released
Steven Edwards On The Future Of ReactOS And Wine

Re:Hmm Running a..

[AstroDrabb]

No. Wine doesn't "intercept" anything. It is not like WINE has some _HUGE_ switch statement where it just "intercepts" Win32 calls and translates those to Linux calls. WINE has _rewritten_ the WIN32 API (well, a lot of it so far). For example, I write a program with an API to control it with functions like:

sendMessage(int, int)
beep(int)
sleep(int)
phoneHome(int)

Now, you come along and rewrite those some functions for your program with the same "function signatures" (which just means the same function names, parameters and return types). Your not emulating/intercepting me, you have _totally_ rewritten what I did on your own. Granted, what I did above was very samll and the Win32 API is HUGE. That is why it has taken the WINE team (the core group is pretty small) a long time to get a large part of the WIN32 API rewritten to the Linux platform. For example there is a Win32 API called CreateWindow. That _same_ function had to be recreated under WINE in Linux. Under Win32, it creates a window with the Win32 API. Under Linux, it takse the same parameters and creates a window using the methods that the Wine team created.

You are correct in the sense that the WINE team has tried to "emulate" the look and feel of the Win32 API. That is why a Win app under WINE often looks the same. They (WINE) have tried to make the windows looks just like a window in Win32. However, at the end of the day, WINE is still not emulating or "intercepting" anyting. They are recreating API's and copying a look-n-feel.

Re:ReactOS?

[gnarlin]

The short of it is that we have some embarassingly bad code in the kernel.

So that means you are really making some headway in duplicating windows properly ;-)

Re:What a horrible idea

[KJKHyperion]

Windows applications are not legacy. Linux is not a Windows replacement. BSD neither. We are totally, absolutely, positively sure: it's a Windows clone we want. We don't all secretly dream running Linux, and in fact several of us must fight the puke back when forced to deal with it (except KDE. I like KDE. I'd like it even more if it ran under Windows). Some have had their weird ideas phase, but you get over it soon.

We're tired of hearing about this every damn time, and I'm not speaking personally here. Even the Linux users among the developers are fed up with that argument. It doesn't make sense, ReactOS is real, is here, today: deal with it already, because at the point it is now, it's not just going to go away.

Your technical argument doesn't make sense, either. One of such DLLs you talk of is called "the Windows kernel", and it's a pretty big piece of software (a 2+ MB binary, for the record). And it has a private API to talk to the HAL. And one to the authentication service. And another to the event logging service. And yet another to the PNP service. Each of these services can be queried by applications with an undocumented RPC protocol. It's a recurring theme in Windows: most APIs have two sides with unknown grounds in the middle, and many DLLs expose multiple client sides. Picture the graph in your mind. No, more arcs. No, way more than that. Yes, you're getting closer, and yes, that arc does go twice the same way. Etc.

One has to wonder why couldn't Wine just provide a loader for Windows executables and let the (air quotes) D-L-L-s (air quotes) do the rest, if your statement had even the slightest trace of truth in it.

Please don't trivialize our work, which is something you apparently don't fathom in the slightest

ReactOS rules!

[808140]

Ok, first off: I hate Windows. I hate its stupid UI, its ugly fonts, and the company that produces it. I jumped ship and switched to Linux before Windows 95 came out. I mean, I hate it, and I would never run an OS that even superficially resembles it. That includes ReactOS.

But.

ReactOS is a perfect example of the OSS spirit. Lots of folks here have been making comments along the lines of "You ought to be working on Linux" or "You ought to be working on WINE" or the like. It surprises me that a site as devoted to the OSS concept would parrot such ridiculous drivel.

It's possible that Linux-based OSS has gotten so popular that we now have lusers of our own. You know what makes a hacker? Someone who codes because he (or she) loves to code. Loves, you know? Not to be productive. Not because they want to change the world. These things may be true of some hackers, but these things alone do not a hacker make.

There was a time when people here respected this. When the majority of Slashdotters were active hackers themselves. Don't be fooled by my high UID -- I remember those times. We wrote software because we loved to. I rather suspect that lots of folks would have told Tim Berners Lee that the web was a dead end idea, or that at the very least it would never be useful. Lots of people have belittled Linux over the years using the same flaccid arguments.

You know GNU? The group that started it all? What was their goal? To produce a free UNIX. Yes, a clone. You understand this? In those days, there was no Windows (1984). A hacker at MIT decided that he wasn't going to put up with this proprietary software bullshit and he said, "I'm going to make a free UNIX clone." And people laughed at him. They said it would never happen. But it did, didn't it? I'm typing this from my Debian GNU/Linux workstation. People like Stallman and Torvalds made that happen. All they wanted was a free OS to replace the one they used at school/work and loved.

Now, most of us (myself included) dislike Windows. We dislike Microsoft (but then, I'm sure RMS disliked IBM, Sun and HP, too). But aren't you missing the point? Some guys like Windows. They like its interface. But like RMS, they demand freedom. Freedom, you know? In this world of the business-friendly "Open Source" movement, people seem to have forgotten this concept, the concept that motivated hackers to create a free UNIX in the first place. It's easy to forget about uncomfortable, uncomprimising ideals like Freedom. But people like Richard Stallman and Theo De Raadt -- and even Linus -- for all their failings -- are motivated by this ideal.

ReactOS is simply another GNU project. But this time, the hackers that have undertaken it aren't fond of the UNIX way. So what? They like an OS I don't like, but so the fuck what? Look at what they're doing. They're creating a free replacement. Free. As in Freedom, you know. So people everywhere that like Windows can use Free Software.

As difficult as it is for me, a unix-geek, to believe, some people don't like UNIX. Some people prefer VMS (I actually quite like VMS and wouldn't mind a FreeVMS). Some people prefer Windows. BeOS. Whatever.

People seem to think that if these guys weren't working on ReactOS, they'd be working on Linux, or BSD, or the HURD, or whatever pet project you have. But that's not how it works. Developers scratch and itch, you know? Because they're coding for love, because they like to code. Not for you. Not so that you can sit on your fat ass and benefit from their work. They do it for themselves, in an ultimately selfish way, to scratch their personal itches. And if you benefit, that's great.

Lusers are people that think FS devs are out to serve them. But guess what: just because you discovered Linux last week and found out that you can run on your machine and get work done doesn't mean that its a "product" that is being "produced" for you to consume. It's a labour of love, made by