wx.NET is a C# wrapper for wxWindows, providing a portable GUI toolkit for .NET programs. wx.NET can be used with various implementations of the CLI, including .NET, Mono, and DotGNU Portable.NET. Other C# wrappers for popular freely available toolkits are GTK# and QT#. Also, more developers are needed to assist porting Mono or dotGNU to Mac OS X.
wx.NET 0.2 Released
About The Author
Eugenia Loli
Ex-programmer, ex-editor in chief at OSNews.com, now a visual artist/filmmaker.
Follow me on Twitter @EugeniaLoli
The Ximian guys don’t care about having an OS X port at all. Or a port to any platform other than x86 Linux for that matter. That is why I am sick of hearing about .Net being portable, based on Mono. Mono only is going to be any good on x86 Linux. The current bunch of core developers don’t really give any priority to other platforms.
So by your logic, Win32 is more portable than .NET because the Wine guys are supportive of a MacOS port?
The portability of a platform is often a function of the openness of the supporting code. That’s why free software is so rapidly ported to Windows and the Mac, but the reverse is not true (and that’s one reason why platforms like windows/mac are a bad thing).
As long as Mono can keep up, as far as I’m concerned .NET is pretty portable (as long as you stick with implemented classes). Whether it works on MacOS or not is entirely irrelevant – somebody, if they cared, could make it work.
So that brings us on to the fact that nobody actually cares about making it work on MacOS. It’s not really used much for desktop apps (but probably will be in the future), and Macs have zero penetration outside of the (primarily home user/personal) desktop. As such, there is little motivation to get a port going.
You are correct that Ximian don’t give a monkeys about MacOS. Why should they? It’s a proprietary platform, with almost no business there. Not only does it go against everything that Ximian stand for (bearing in mind that they GPL almost all their software), but there’s no chance of making any money there.
If there was somebody sufficiently motivated I’m sure there’d be a port, but there isn’t. End of story.
The article mentions that “to assist porting dotGNU.. to OS X” , which is slightly incorrect. DotGNU has been running well on OS X for the last 7 odd months. (of course now you know why it’s called DotGNU “Portable”.net
Have a look at http://dotgnu.org/screenshot6.html (and the rest of the OS X screenshots on http://dotgnu.org/screenshots.html )
DotGNU has been running even GUI WinForms app on OS X. The entire suite is fully functional on OS X (provided you have X11 on it).
If there’s any particular problem wx.NET is facing on DotGNU + OS X , do tell the developers lists
Now? Yeah. For sure. Why? Currently, x86 is Ximian’s market, if they haven’t delivered to it, why start a port to OS X? For fun? But in the future, would they port it to OS X? Now let’s see – would they make any money? If yes, then hell yes. If no, then hell no they aren’t gonna port Mono to OS X. Are they gonna prevent people from porting Mono to OS X? Hell no, again.
But expecting Ximian to port to a platform that isn’t even close to being its targeted market is kinda lame. Besides, I would expect them to support officially FreeBSD/NetBSD/OpenBSD before OS X..
If Sun refuses to port their Java VM to, for example, Linux (for the sake of argument), does it mean that Java is not portable? No. Anyone can implement Java. ANd to the lesser extend, .NET too. DotGNU running on OS X – that is portablity right? Even though it is limited feature-wise, but the same for Java on Mac in the early days.
How about actually READ the MSIL specifications. There is NOTHING stopping someone from porting mono to MacOS and providing a GUI via qt#.
The Ximian guys do care about getting Mono running on OS X. It’s just not a very high priority. PPC support and simplifying the porting process were two of the reasons for writing the new JIT, which went into use in Mono 0.24. At present, there is some support in the JIT for PPC chips — just look in the source (the `mono’ module, in the mono/mini directory).
The problem is that OS X doesn’t have enough priority over other matters, such as completing the class libraries and bug fixing. Remember, Mono is being used in real products as we speak (the SourceGear Vault source code management tool; see http://www.ximian.com/about_us/press_center/press_releases/index.ht… ), so class library stability is vitally important, far more important than Mac support at this time.
There are at least two ways to fix this: (1) make it a priority through money (I’m sure Ximian would a contract to finish the Mac port), or (2) contribute to the project (making it a priority for you).
Personally, I’d love to work on the OS X port, but the lack of any Mac hardware keeps that from happening for me…
But first the JIT-Compiler of the mono project will have to stabilize. What good would it be if somebody had spent a lot of time porting the old JIT to OS X now that the new JIT compiler is out… But when mono nears 1.0 somebody will port it to OS X.
MSIL is a really beautiful instruction set that has been designed to be easily portable (read the specs before you flame me), and the G5 PPC with AltiVec is a very attractive target.
I think that Ximian has no resources to do a good port to PPC unless somebody pays them, but Apple, IBM or some computer science student will do it. Mapping msil to PPC+AltiVec should be much more fun than mapping msil to the braindead x86 ISA.
MSIL is a really beautiful instruction set that has been designed to be easily portable (read the specs before you flame me)
>>>>>>>>
That’s because MSIL, along with large parts of the low-level .NET runtime and architecture was not made by Microsoft. Microsoft bought out the company that invented the technology after thelow-level stuff was already in place. Portability at Microsoft is not a high priority. Its the same company that took a beautifully portable OS like NT 3.x and turned it into Windows XP.
There are many other ways you can help out Mono which will give the main developers more time to work on things like porting to ppc. You can find out more info on any of these things on http://go-mono.com
1. Write Gtk# documentation
2. Write Test cases
3. Implement a class for the class library
4. Fix bugs from bugzilla
Why two projects to achieve the same goal ? Why dont they just work together. How far are the Gnu guys with their dotgnu exactly ? I read it s possible to use windows.forms with dotgnu ? does it mean that dotgnu is better than mono ?
MSIL is a really beautiful instruction set that has been designed to be easily portable (read the specs before you flame me),
Can you elaborate on ‘portable’ please ? Because I had a look on the specs and I remember that there are some choices that make MSIL a HUGE pain for low/mid end embeded device. On those devices, you have to interpret the bytecode (no enough power or RAM for real JIT). And the drop in performance is high compared to java bytecode.
I had the feeling that MSIL was targeting JIT only execution and, in consequences, devices with lot of RAM (8/16Mo), enough CPU power (> ~250 Mhz ) and fast storage (Small Hard Disk, Flash is too slow) [the Assembly Cache a must have].
I guess that the only target in embedded world for .NET is High end PDA that we will see in 2004.
Portable.net was started before Mono , IIRC the main developer had approached Ximian with his work when Mono was announced. IIRC, nothing came out of it.
Mono CVS does included about 50,000 lines of DotGNU code that has been relicensed from GPL to X11 for Mono’s use.
(since this is actually supposed to be a Wx.net discussion,. I’m limiting the comments)
I do think you have not looked a bit closer at DotGNU’s offering before commenting on memory requirements.
Portable.net does run on high-end PDAs in full capability, but the real limitation is not the JIT or the engine. (yes, full JITs take a lot of memory). But that’s not the end of it.
The portable.net engine can be trimmed down (./configure –profile=tiny|small|kernel) at compile time to suit almost any system. The library being the bulk of writable memory (IL is compressed on disk and has to be uncompressed into memory) can also be trimmed similarly of features, optional and debug regions.
Good memory efficent stuff can be written out for IL , but who’s interested ? (of course running wx.NET on a PDA is a distant dream , Qt# + Qt/E is more promising there)
Well, so far nobody has responded to running DotGNU on OSX or come up with screenshots of DotGNU running wx.NET on OS X
i just hope that they wont get any troubles with microsoft and both portable.Net and mono can continue their work. I m wondering why they dont just ask permision of microsoft to port CLR to linux. The freeBSD developers have also got the permision from SUN to port the JVM to FreeBSD. The same could happen to .Net. Or has someone done it and got a negative answer from Microsoft. I mean, they created .Net to be cross platform, didnt they ? When it s not going to be cross platform, why wasting our time on it. The applications running directly on the OS are much usable than those running on the vm.
DotGNU was started before the public specifications for the file formats existed, so it contained a lot of reverse engineered file formats. Not a foundation you want to build on. And this was an issue for the Mono guys, which wanted to have a solid foundation.
Mono does in fact use a chunk of code that was contributed by the DotGnu folks, but it is not 50k lines of code, it is a lot less, the 50k lines of “code” are nothing but data-tables that were generated from the public Unicode specifications.
Both projects (Mono and DotGnu Portable.NET) are implementing the exact same thing. There is no reason for the existance of the two. Mono has a JIT, Mono has ASP.NET, ADO.NET and a C# compiler which is more mature. DotGNU has the promise of being a unified virtual machine for everything (personally, I think they are spreading themselves too thin).
The DotGNU folks have a setup to reuse all the Mono libraries, so the only differences seem to be the use of an interpreter vs a jit compiler. In some areas DotGNU is more advanced, but the overall inmaturity of their code base is a problem.
DotGNU stated that they had “generics working”, turns out that nothing really works; They got the compiler to parse the code, and the assembler to assemble it, but none of it is really useful. It is probably 20% done, but they sure like to claim they were “there before Microsoft”. In general, you will see a lot of this coming from the DotGNU camp.
The Mono folks in general are more focused on .NET and less interested in flamewars.
Now, that is what I call “informative comment”. Thank you Jaime.
Rayine Hashem,
yes, I know that MSIL was designed by another company and not by microsoft, just like they bought Anders Hejlsberg to design C#. But that does not change the fact that it is a beautiful design. Would you rather have some kludge like MFC that is designed by microsoft themselves? At least they do not suffer from not invented here syndrome like so many other huge companies…
I agree that NT 3.x was much more portable and well designed than WinXP. But even if microsoft should turn .NET into a bloated platform-dependent nightmare, there is always mono…
Sch,
You are right. MSIL was designed from the start to be JITed, so it might be a problem for extremely low end hardware. But I think with a few compromises it should be possible to run MSIL even on very small processors. Since you can write quite complex programs in .NET using only value types and thus not requiring garbage collection, one could argue that MSIL is much better suited for small memory-constrained systems. In java on the other hand, writing complex programs without using the heap is a major PITA.
Just so it is known, mono is not limited to running on x86 linux now. It runs fine (albeit not with the JIT yet; it must use the interpreter) on PPC Linux. I would guess that it would work (using the interpreter) on other Linux architectures, too.
Gopal mentions some of the features of Portable.NET and you immediately claim that he’s flaming? It seems the only one interested in flaming is you. Typical. Every time DotGNUers mention anything about PNet, Monophiles immediately make the baseless claim that they’re flaming Mono. Grow up. Is your position really so tentative that the mere existance of competition is an attack upon it?
Rich
Part of the beauty of the Portable.NET design is that JITting can be implemented incremementally. The problems of having to write an all or nothing JIT are eliminated with this design. Those instructions that are easy to convert to native code are the first ones to go native, while the tough opcodes continue to be interpreted (until some brave soul decides to tackle them
. Note, the PNet interpreter interprets its own intermediate language, CVM, not IL… IL->CVM or IL->CVM->native is the way the code goes. This gives a huge performance boost over IL interpreters because CVM is non-polymorphic.
Rich
DotGNU was started before the public specifications for the file formats existed, so it contained a lot of reverse engineered file formats. Not a foundation you want to build on. And this was an issue for the Mono guys, which wanted to have a solid foundation.
The techniques that I used were no different than those used by the Samba team to determine how the SMB/CIFS protocol works. Eben Moglen, legal counsel at the Free Software Foundation looked over what I had done and found no problem with it.
Furthermore, that was the Beta 1 file format, which is now obsolete – even Microsoft doesn’t support it any more. None of that code remains in the Portable.NET tree. The Beta 2 code was built from the spec.
In fact, the only “evidence” for the supposed reverse engineering that I did is in a posting by Miguel de Icaza, soon after the Mono project started, where he made that unsubstantiated claim in an effort to damage my reputation and scare people away from my project.
I did nothing wrong. However, by replaying this same baseless libel over and over you prove who is really interested in perpetuating the flame war.
We were kinda discussing Wx.Net on “Mac OS X” … PPC linux is kinda easier to port to ?