Who said .NET only runs on Windows? Builder AU have published an article to introduce developers to DotGNU and how to get .NET applications running on Linux and other flavours of UNIX.
Running .NET on Linux with DotGNU
About The Author
Eugenia Loli
Ex-programmer, ex-editor in chief at OSNews.com, now a visual artist/filmmaker.
Follow me on Twitter @EugeniaLoli
Does anybody know where I can find .deb packages (binary or source)? The Debian repository mentioned on dotgnu.org is incomplete and google hasn’t been of much help so far…
dotgnu.org DNS is b0rked … please excuse bind and visit
http://gnu.org/projects/dotgnu/ [ and mirrored on *all* GNU mirrors]
I’m kinda lost .. I thought the stuff was in
http://ajmitch.dhis.org/debs
But that’s Forbidden … but the debs are already built and
in http://ajmitch.dhis.org/debuild/dotgnu/pnet/ and http://ajmitch.dhis.org/debuild/dotgnu/pnetlib/ ??.
Anyway the hard dependencies of these debs are X11 , libreadline and libc
can someone explain the naming convention of DotGNU to me? you have all these pnet libraries (oh, duh, portable.net, i get it), then to run things you use a command named ilrun, and then there is something called treeC?
also how mature is DotGNU? i wrote a real quick and dirty mono app a few weeks ago and was happy to see it working on both my mac where it was compiled and on my windows computer. can i expect the same from DotGNU?
Why use DotGNU? Mono seems to be light years ahead of DotGNU.
“also how mature is DotGNU? i wrote a real quick and dirty mono app a few weeks ago and was happy to see it working on both my mac where it was compiled and on my windows computer. can i expect the same from DotGNU?”
DotGNU is not really a compiler environment like Mono, it is a runtime that runs C# programs compiled on Windows & Microsoft’s own compiler, for example. Mono doesn’t do this – You need to compile the software on Mono to get it run on all platforms.
[i]You need to compile the software on Mono to get it run on all platforms.[i]
Can you give us the URL for a page that can back that statement up?
I’ve had a command line program compiled on Windows, linkedd against a DLL that was compiled on Linux, and runs fine on Linux, Windows and Solaris. On Windows I used VS.Net, and used Mono on the other platforms.
I think he meant that for the gui to work you have to compile in mono, using something like #gtk, or wx.net. DotGNU attempts to replicate the whole Windows.System.forms namespace also, as far as I know. I don’t believe this is complete yet, however. The Mono project doesn’t see this as a priority, it is just intending to be a useful c# environment and compatible with that ecma standard, not necessarily ompatible with the Microsoft api, which is very windows orientated.
Both DotGNU and mono claim solaris support, but I can’t see packages for these anywhere – yet there is every kind of linux package imaginable.
Has anyone had good experiance of building and running DotGNU, or mono, under solaris.
“Why use DotGNU? Mono seems to be light years ahead of DotGNU.”
Light years ahead in marketing indeed.
(No I don’t doubt that Mono is more advanced – it’s jsut that you don’t hear all that much about DotGNU though it seems to hold some promise)
Did Microsoft open .Net specifications under GPL? 😉
What are you talking about here?
I can install Oracle under Linux for free!!! WoW.
(of course untill Oracle is unaware or just not interested to kill me, pobre).
DotGNU is not really a compiler environment like Mono, it is a runtime that runs C# programs compiled on Windows & Microsoft’s own compiler, for example. Mono doesn’t do this – You need to compile the software on Mono to get it run on all platforms.
<p>
I’m sorry, that’s simply untrue. You do not need to compile software on Mono to get it to run on all platforms. You can compile using Visual Studio.NET/csc and move the assembly to Linux and run with Mono. If you’re referring to the lack of a good Winforms support in Mono, that problem is being addressed with high priority by a team of 4 Novell hackers in Provo, Utah. They are making good progress so far, it seems.
<p>
MS didn’t put it under the GPL. But something standardized through ECMA is usable for every one.
I wish people that have obviously not too much of an idea what they are talking about would just shut up and not spread any misinformation.
I (and many other mono/DotGNU developers) are sick of this, and every news ends in an “why should I use A and not B” or “B is much better than A” etc. although those people have no idea what they are saying, they just post their useless comment.
To answer and correct a few things I read above:
– treecc is a compiler-compiler tool which was used to write the Portable .NET compiler, it is not needed to use the compiler, just to compile the compiler
– DotGNU isn’t a “runtime only”. ‘cscc’ is the compiler, ‘ilrun’ is the runtime engine and there are many others ([dis]assembler etc. most start with ‘il…’)
– “Why bother with DotGNU?”; Dude, I think you have not looked at Mono’s source neither at DotGNUs, they are different architectures and a lot of things are designed and implemented in a totally different way and you should choose which one fits you better (but you are probably not smart enough anyway if all you can do is senseless trolling).
– It is very likely that apps that “were written for mono” also work with Portable .NET, although Mono currently has a more complete library (besides WinForms, but they recently started a managed approach, but mono’s winforms probably be usable in a few months, too)
– There are also licencing differences (Mono is using the MIT X11 lib for their libraries and DotGNU is using GPL (+linking exception) or LPGL, which also makes a difference when it comes to software patents or proprietary software.
– Nelly, I don’t use solaris but I am currently talking to a guy in #dotgnu on the Freenode IRC Server which is running pnet on solaris
– It is not true that DotGNU only tries to have a usable WinForms and other things are minor.
You can also use wxnet, qt#, gtk# (and probably others) with pnet.
And since Gnome is also part of GNU (just like DotGNU), all the things that go into the direction of gtk# are important as well. For some reason it’s commong believe that Gtk# doesn’t work with pnet, but it does (see http://demo.dotgnu.org/~t3rmin4t0r/gtk-sharp-screenshot.jpg), it’s just not yet as well supported as it is with mono.
There are more differences but also a lot of common goals and I can just repeat myself:
If you don’t know what you are talking about, don’t post any rumours or flame comments, it won’t help your preferred project.
Quite agree here. however, can you explain your point of view on:
– “Why bother with DotGNU?”; Dude, I think you have not looked at Mono’s source neither at DotGNUs, they are different architectures and a lot of things are designed and implemented in a totally different way and you should choose which one fits you better (but you are probably not smart enough anyway if all you can do is senseless trolling).
I wonder what are thoses architectural differences and no one ever really talks about it. I don’t really feel like digging the source of both to find out however :/ (im lazy ? yes :p)
If you’re referring to the lack of a good Winforms support in Mono, that problem is being addressed with high priority by a team of 4 Novell hackers in Provo, Utah.
Aw, man. Now that is the kind of talk I like to hear regarding these things!
@a: You’d really have to stare at the source code of each project to understand. DotGNU takes a tightly abstracted approach, Mono takes a tightly integrated approach. That is not to say that Mono is portable or that DotGNU is abstraction hell, just that they each serve different benefits. You’d probably want to use DotGNU for embedded systems over Mono, for example.
For some reason it’s commong believe that Gtk# doesn’t work with pnet, but it does (see http://demo.dotgnu.org/~t3rmin4t0r/gtk-sharp-screenshot.jpg), it’s just not yet as well supported as it is with mono.
The few problems mainly involve the p/invoke and marshalling code in pnet, which should be fixed soon (needs a rewrite, which, afaik, will be done along with the libjit backend integration).
Rich
The Mono project doesn’t see this as a priority, it is just intending to be a useful c# environment and compatible with that ecma standard, not necessarily ompatible with the Microsoft api, which is very windows orientated.
Actually it’s pnet which has aimed more for ECMA compliance; pnetlib has had “#if !ECMA_COMPAT” since day one, while mono’s library still (at least last time I checked) doesn’t have any clear divide between ECMA and non-ECMA code. The main concentration of effort in pnet has been on ECMA compliance, with non-ECMA stuff given secondary importance. It’s funny because this is actually one of the things Miguel, et. al., used to complain about in their countless flames on pnet, and now they’ve done a 180 (not the first time). The pnet approach to the completely unportable parts of the API has been to fake it with do-nothings or throw NotSupportedExceptions, while mono wasted two years on wine-based winforms so the, rare, completely unportable winforms apps would run. Portable.NET puts portability and ECMA compliance first.
Rich
Why use DotGNU? Mono seems to be light years ahead of DotGNU.
Mono is “light years ahead”? *cough*bullshit*cough* Slapping a 1.0 on a buggy as hell library doesn’t make the library any less buggy. There are some things which are more advanced in the Mono library, like System.Data, and there are other things which are more advanced in pnetlib, like System.Windows.Forms. Things such as mono’s System.Data can be used with pnet, and the wine-based winforms of mono has recently been scrapped in favor of a fully managed winforms (like what pnet has had for over a year), so I fail to see the “light years” of which you speak.
If you want to talk about runtimes, the Mono JIT is further along, but the Mono interpreter has only recently adopted the Converted Virtual Machine approach first developed by pnet’s lead developer, Rhys Weatherly, and used for several years now in DotGNU Portable.NET’s ilrun. Mint used to be about 100 times slower than ilrun, while ilrun, an interpreter, averages only about half the speed of mono. The development of libjit, a JIT library of use to all free(dom) software runtimes (i.e. not pnet-specific), by DotGNU Portable.NET’s lead developer should soon shorten that small gap. Libjit, because it’s not pnet-specific and has already gained some interest from some free(dom) software Java runtime hackers, and because Rhys seems physically incapable of writing unportable code, should also support more archs than mono’s JIT before very long. It also helps that Rhys can write more good code in a night than most hackers can in a year, which is the main reason why pnet hasn’t fallen all that far behind, despite having, at best, 1/20th the manpower.
If you want to talk about compilers, do you prefer straight portable ansi C compilable by gcc (pnet’s cscc), or something written in itself which requires lots of bootstrapping headaches just to get built (mono’s mcs)? The pnet compiler, just from a design perspective, is “light years ahead” of the mono compiler; the use of the aspect-oriented compiler-compiler, treecc, to deal with the complexities of semantic analysis certainly beats the hackish design of mcs. It’s not surprising, considering cscc was written by an experienced compiler writer, while mcs started as just a toy developed by people with no compiler writing experience. The error messages of mcs also suck (dumping lots of useless information on compiler internals in leiu of actually useful information) compared to cscc; to be fair, csc, the MS.NET compiler, appears to have the best error messages, though cscc’s aren’t far behind.
Finally, I’ll preempt any talk about duplication of effort by pointing out that Portable.NET started long before Mono (actually, long before even DotGNU), Miguel knew about pnet long before he started mono, and it is the Mono leadership which has refused, on countless occasions, to cooperate on any level with pnet, despite repeated attempts, by both the DotGNU steering committee and various pnet hackers, at cooperation (perhaps not such a bad thing considering the official mono coding style is fugly, while “Rhys-style” is beautiful). DotGNU also doesn’t ban people from their mailing lists just for using Mono; the reverse cannot be said… just ask the Qt# guys.
It’s nice that you monophiles have stopped ignoring pnet altogether, but do you really have to start up again on the flames and trolling? I’m assuming that’s what your intent is, though perhaps you just haven’t noticed the 3 million other posts identical to your own, which have been made both here and on Slashdot (as well as other sites) over the past few years, every time DotGNU or pnet is mentioned? Don’t you guys ever get tired of being *ssholes towards us? Aside from the better design and nicer coding style of pnet, it’s the nastiness towards it, from people such as yourself, which turned us former mono hackers/supporters (yes, most of us started on mono) into pnet hackers/supporters. You don’t see us going onto threads about Mono and asking “Why Mono?”, do you? Portable.NET was here first, so it’s a valid question, but we actually have something called “respect”, and like to practice something called “civility”; you might want to look those two terms up.
Rich
Ah Rich, a man who can only flame.
If you can not bootstrap Mono, is because you did not bother
to read the README file. Anyone downloading the mono tarball
should have no problem to get Mono installed in a matter of
minutes.
Rich is famous for claiming that he would write an XmlSerializer in days. Wait, did I say days? Minutes! Am telling you! Minutes!
So he was going to write one in Minutes, but I guess it was
too “easy” for him, so he copied Mono’s version into Portable.NET (nothing wrong, the license allows it of course), but you gotta love the macho position he takes
on the forums: `our code is cleaner’, `their is ugly’,
`we are simple’, `they are hard’, when the man is incapable
of writing code.
Yes Rich, I know you wrote some stubs for Windows.Forms in Mono, which we sadly could not use, because, well, they were only that: stubs.
Miguel
I wish people would conduct their flamewars in private, rather than on public forums. That way, people can evaluate them based on the quality of their work, rather than the patheticness of their flames.
Binary is the one true programming language. HAND.
1) I respond to flames, I don’t start them.
2) Bootstrapping problems with mono have been the reasons stated for interest in pnet by several of the people who’ve come into #dotgnu on freenode.
3) When the f*ck did I say that? I may have underestimated how much work it would be (thanks almost entirely to the total lack of documentation for it), and I did decide to use mono’s xmls11n as a temporary measure because I have other things I need to do currently, but I never said I could do it in days. I had planned originally to do xmls11n over the course of this summer (that’s _3 months_, jackass), as part of my work to get the Trumpf company’s libs working on pnet (still pissed that they chose pnet over mono?). They only need soap support, so that’s 3 months with the potential to cut some corners temporarily. It was decided, however, that I would work on other things, and someone else would work on xmls11n; mid-July rolled around and I found out that that person was not going to work on it, so I tried to get it done. I spent a little over a week on it, and I did get a lot done, but it was nowhere near enough in enough time; I have other things which I need to get done. At that point I made the decision, reluctantly, to import mono’s xmls11n; I still intend to write a pnet version when I have the time because I hate having to throw away the code I’ve already written, I want to have pnet-style S._() error messages in it, and I’d rather I have to fix my own bugs instead of yours (i.e. easier to maintain if I write it myself, so I know it inside and out).
4) I can’t code? I may not be all that impressive when it comes to coding speed (or design, after I’ve been dealing with MS apis for far too many months) but I can certainly code. I’ve written several of the winforms controls for pnet, some of the postscript printing backend for sys.drawing, some of the drawing routines in sys.drawing.graphics, most of the internal calls for sys.reflection.emit, most of the xml text reader, made various fixes to stuff all over pnetlib, and even some fixes to both the compiler and runtime. Through all of that hacking, yes, I’ve found Rhys’ coding style and designs _much_ nicer than what I’ve seen in mono. Tum, another former mono hacker, the guy who wrote pnet’s threading code and can certainly never be accused of not being able to code, seems to have about the same opinion of both mono coding style and design, as do many others I’ve talked to. You can read the #dotgnu logs if you don’t believe me, since, unlike mono, we don’t do most of our communication in secret; you can even laugh at my occasional psychotic rants on various things (e.g. several on gutting Fritz Hollings, iirc). Hell, next time you won’t have to put words in my mouth to make fun of me; I make an ass out of myself just fine without your help. Granted the coding style gripes are just a matter of opinion, but there’s no denying pnet has a better design. Otherwise why would you keep trying to copy it?
5) Actually, I implemented some of those classes, but what about stubs is unusable? How were the stubs any less usable after the move to wine-based winforms than they were before? Also, trying to belittle my work on mono belittles the work of all those who’ve stubbed for mono; never mind… I forgot who I was talking to you… we’re all so much lower than the great and mighty Fuhrer Miguel. You and lupus really should try growing up some time; it’d be nice not to have to feel like I’m in kindergarten when dealing with you two, for once. Perhaps if you hadn’t banned Gopal from the mono list I might not have left mono and you might’ve gotten a lot more code from me; then again, I thought the wine-based winforms switch was a bad idea even then, but I probably would’ve found something else to work on.
6) Why’d you guys suddenly decide to stop ignoring us and start flaming and trolling again? We actually seem to have fewer active people when you’re not constantly attacking us, so are you just too stupid/arrogant/hateful to continue ignoring us, or do you have something new up your sleave?
Rich
By the way, Miguel, strawman and ad hominem won’t win a debate, but nice try.
Rich
You both have a lot of interesting stuff to tell us (The Osnews readers).
But, picking on each other is just …. funny ?
Or, is it just waste of energy ?
I like both projects, both are very intersting projects and implementations.
I wish BOTH projects and teams a lot of success.
Enjoy the coding, forget the war.
It’s so nice to see the [self proclaimed?] representatives of pnet being so professional – I guess this is a coders version of a temper tantrum – LOL.
… representative (singular)
Ah Rich, a man who can only flame.
Sorry Miguel. As much as a respect the Mono and DotGNU projects, the DotGNU developers are light-years ahead in two important aspects – trust and respect. Re-read your own mailing list comments for pointers on this.
Rich is famous for claiming that he would write an XmlSerializer in days. Wait, did I say days? Minutes! Am telling you! Minutes!
Classic example right there. Even if he did say that, what’s the point of dredging it up? Besides, he probably has other things to do than getting paid a salary to hack on a free software project and ridicule other people. Some people do have jobs, you know?
Maybe Novell should simply contribute to a free software project that is outside the boundaries of Novell?
Yes Rich, I know you wrote some stubs for Windows.Forms in Mono, which we sadly could not use, because, well, they were only that: stubs.
Fine, OK, you didn’t use Rich’s stubs (wow).
You could of course try addressing Rich’s points one by one, and saying why DotGNU cannot do those things, why they are pointless, why Mono has implemented things in a different way… You know, that’s called debate and is something I thought you might have done at Novell – it’s pretty much a pre-requisite for work at such a company.
It’s so nice to see the [self proclaimed?] representatives of pnet being so professional – I guess this is a coders version of a temper tantrum – LOL.
I’m merely an outsider looking in who has observed over time. If you want to know why Rich has had a bit of an outburst (a bit ill-advised, I know), read the mailing lists at DotGNU and Mono and ask yourself where this has most likely come from. Until you do that do not question the professionalism of anyone.
Nice flamewar. But instead of flaming each other, you should work on the horrible performance of methods involving valuetypes in both runtimes.
Whoever gets inlining and subsequent optimizations like temporary struct elemination done first is the best coder, and gets 100$ from me.
Here are the details:
http://lab.msdn.microsoft.com/productfeedback/viewfeedback.aspx?fee…
You have to make both loops in the sample program run with identical performance. The challenge runs out when microsoft has implemented this feature, so there is plenty of time… 🙂
best regards and happy coding
Rüdiger
That’s constructive thinking!
Portable.NET also runs nicely on the Zaurus PDA (which runs Linux). An older vesion of Portable.NET for the Zaurus is available here:
http://radio.weblogs.com/0102385/categories/zaurus/2004/06/22.html#…