+<a href="#basics">Basics</a><br>
+<a href="#novell">The Novell Role in the Mono project</a><br>
+<a href="#gnome">Mono and GNOME</a><br>
+<a href="#gui">Building GUI applications with Mono</a><br>
+<a href="#msft">Mono and Microsoft</a><br>
+<a href="#platforms">Mono platforms</a><br>
+<a href="#compatibility">Compatibility</a></br>
+<a href="#pnpproject">Mono and the Portable.NET Project</a><br>
+<a href="#webservices">Web Services</a><br>
+<a href="#asp">Mono and ASP.NET</a><br>
+<a href="#ado">Mono and ADO.NET</a><br>
+<a href="#monodoc">MonoDoc</a><br>
+<a href="#devel">Development Tools and Issues</a><br>
+<a href="#java">Mono and Java</a><br>
+<a href="#extending">Extending Mono</a><br>
+<a href="#portability">Portability</a><br>
+<a href="#reuse">Reusing Existing Code</a><br>
+<a href="#gcc">Mono and GCC</a><br>
+<a href="#performance">Performance</a><br>
+<a href="#licensing">Licensing</a><br>
+<a href="#patents">Patents</a><br>
+<a href="#etc">Miscellaneous Questions</a><br>
+<a href="#obfuscation">Obfuscation</a></br>
+<a href="#problems">Mono Common Problems</a><br>
+
+A <a
+href="http://www.monohispano.org/tutoriales/mono-puf//">Spanish
+translation</a> is also available (it is outdated though)
+
+<a name="basics"></a>
** Basics
-Q: Is Mono the same as Microsoft's .NET initiative?
+Q: What is Mono exactly?
-A: It is not.
+A: The Mono Project is an open development initiative sponsored by
+ Ximian that is working to develop an open source, Unix
+ version of the Microsoft .NET development platform. Its objective
+ is to enable Unix developers to build and
+ deploy cross-platform .NET Applications. The project will
+ implement various technologies developed by Microsoft that have now
+ been submitted to the ECMA for standardization.
- .NET is a company-wide initiative at Microsoft that
- encompasses many different areas. The .NET development framework,
- Passport, Biztalk, new server products, and anything that is
- remotely connected to .NET gets the ".NET-stamping" treatment.
- Some components of Microsoft's .NET initiative have been announced
- and some others are in the works.
+ The Mono project has also sparked a lot of interest in developing
+ C#-based components, libraries and frameworks. Today Mono is not
+ limited to implement the .NET Framework, but also contains other
+ components. Some of the components of the Mono platform were
+ developed by the Mono team, and some others we have incorporated
+ from other open source efforts, the most important ones:
- Mono is a project to implement several technologies developed by
- Microsoft that have now been submitted to the ECMA Standards Body.
+ <ul>
+ <li><a
+ href="http://remoting-corba.sourceforge.net/">Remoting.CORBA</a>: A
+ CORBA implementation for Mono.
+
+ <li>Ginzu: An implementation on top of Remoting for the <a
+ href="http://www.zeroc.com">ICE</a> stack
+
+ <li><a href="http://gtk-sharp.sf.net">Gtk#</a>: Bindings for
+ the popular Gtk+ GUI toolkit for Unix and Windows systems.
+ Other bindings are available: Diacanvas-Sharp and MrProject.
+
+ <li><a
+ href="http://www.icsharpcode.net/OpenSource/SharpZipLib/Default.aspx">#ZipLib</a>:
+ A library to manipulate various kinds of compressed files and
+ archives (Zip and tar).
+
+ <li>GlGen (available from the Mono CVS): Bindings for OpenGL.
+
+ <li>Mono.LDAP: LDAP access for .NET apps.
+
+ <li>Mono.Data: We ship support for Postgress, MySql, Sybase,
+ DB2, SqlLite, Tds (SQL server protocol) and Oracle databases.
+
+ <li>Mono.Cairo: Bindings for the <a
+ href="http://www.cairographics.org">Cairo</a> rendering
+ engine (Our System.Drawing is implemented on top of this).
+
+ <li>Mono.Posix: Bindings for building POSIX applications using
+ C#.
+
+ <li>Mono.Http: Support for creating custom, embedded HTTP
+ servers and common HTTP handlers for your applications.
+ </ul>
+
+Q: What is the difference between Mono and the .NET Initiative?
+
+A: The ".NET Initiative" is a somewhat nebulous company-wide effort by
+ Microsoft, one part of which is a cross-platform development
+ framework. Mono is an implementation of the development framework,
+ but not an implementation of anything else related to the .NET
+ Initiative, such as Passport or software-as-a-service.
Q: What technologies are included in Mono?
compiler, and a garbage collecting runtime.
* A class library that can work with any language
- which works on the CLR.
+ which works on the CLR. Both .NET compatible class
+ libraries as well as Mono-provided class libraries
+ are included.
* A compiler for the C# language. In the future we
might work on other compilers that target the Common
Language Runtime.
-
- Windows has compilers that target the
- virtual machine from
- <a href="http://msdn.microsoft.com/net/thirdparty/default.asp#lang">a
- number of languages:</a> Managed C++, Java Script,
- Eiffel, Component Pascal, APL, Cobol, Oberon, Perl,
- Python, Scheme, Smalltalk, Standard ML, Haskell,
- Mercury and Oberon.
</ul>
+
+ Windows has compilers that target the virtual machine from <a
+ href="http://msdn.microsoft.com/net/thirdparty/default.asp#lang">a
+ number of languages:</a> Managed C++, Java Script, Eiffel,
+ Component Pascal, APL, Cobol, Perl, Python, Scheme,
+ Smalltalk, Standard ML, Haskell, Mercury and Oberon.
+
The CLR and the Common Type System (CTS) enables applications and
- libraries to be written in a number of languages. Classes and
- methods created in one language can be used from a different
- language.
+ libraries to be written in a collection of different languages that
+ target the byte code
This means for example that if you define a class to do algebraic
manipulation in C#, that class can be reused from any other
Q: Where can I find the specification for these technologies?
-A: You can find the work-in-progress documentation from the T3G ECMA
- group here:
+A: You can find the information here:
- <a href="http://www.dotnetexperts.com">http://www.dotnetexperts.com</a>
+
+ C# <a href="http://www.ecma.ch/ecma1/STAND/ecma-334.htm">http://www.ecma.ch/ecma1/STAND/ecma-334.htm</a>
+
+ CLI <a href="http://www.ecma.ch/ecma1/STAND/ecma-335.htm">http://www.ecma.ch/ecma1/STAND/ecma-335.htm</a>
Q: Will you implement the .NET Framework SDK class libraries?
A: Yes, we will be implementing the APIs of the .NET Framework SDK
class libraries.
-Q: What does Mono stand for?
+Q: Will you offer an ECMA-compliant set of class libraries?
-A: Mono is the word for `Monkey' in Spanish. We like monkeys.
+A: Eventually we will. Our current focus is on inter-operating
+ with the Microsoft SDK, but we will also offer an ECMA compliant
+ subset of the libraries.
-Q: When will you ship it?
+Q: What does the name "Mono" mean?
-A: We do not know when the code will be shipped. The more
- contributions we get to the project, the sooner it will ship.
+A: Mono is the word for `monkey' in Spanish. We like monkeys.
- A rough estimate is that we might be able to run our C# compiler on
- Linux by the end of the year. That means running the Windows
- Executable generated by a Microsoft .NET compiler on the Linux
- platform.
+Q: Does Mono work today?
- We expect that doing GUI applications will require more work on the
- class libraries. That could take another six months.
+A: The execution engine works on various platforms, we support
+ Just-in-Time and Ahead-of-Time compilations on Intel x86 machines
+ (and soon PowerPC).
+
+ The class libraries are mature enough to run various real
+ applications: our C# compiler, ASP.NET, and Gtk#-based
+ applications.
+
+Q: When will you ship Mono?
+
+A: Please see the <a href="mono-roadmap.html">Mono Roadmap</a> for
+ more details on the release plans.
Q: How can I contribute?
A: Check the <a href="contributing.html">contributing</a> section.
-Q: You guys should innovate instead of copying.
+Q: Aren't you just copying someone else's work?
-A: In this particular case, we see a clear advantage in the platform
- and we are interested in using the features of the CLI on open source systems.
+A: We are interested in providing the best tools for programmers to
+ develop applications for Free Operating Systems. We also want to help
+ provide the interoperability that will allow those systems to fit in
+ with other standards.
- We have decided that we should spend our limited resources towards
- implementing an existing specification instead of designing and
- implementing our own.
+ For more background, read the <a href="http://www.go-mono.com/rationale.html">Mono
+ Project white paper</a>.
+ the project.
- Designing and implementing our own would be possible, but it doesn't make
- sense to do that just because the specification comes from a
- proprietary vendor.
+Q: Miguel said once that Mono was being implemented in COBOL. Is that true?.
-** Ximian
+A: No. It was a joke.
-Q: Why is Ximian working on .NET?
-A: We are interested in providing the best tools for programmers to
- develop applications for Free Operating Systems.
+<a name="novell"></a>
+
+** The Novell Role in the Mono Project
+
+Q: Why is Novell working on .NET?
+
+A: Novell is interested in providing the best tools for programmers to
+ develop applications for Free Operating Systems.
For more information, read the project <a
href="rationale.html">rationale</a> page.
-Q: Will Ximian be able to take on a project of this size?
+Q: Will Novell be able to take on a project of this size?
-A: Ximian will not be able to taken on the whole project on its own.
- Mono will be a free software/open source community project, that is
- the only way we can hope to implement something of this size. You
- can <a href="contributing.html">contribute</a> to this effort.
+A: Of course not. Novell is a supporter of the Mono project, but the only way
+ to implement something of this size is for the entire free software
+ community to get involved. Visit the <a href="contributing.html">contributing</a>
+ page if you'd like to help out.
-Q: What pieces will Ximian be working on?
+Q: What pieces is Novell working on?
-A: We will focus on building a development and execution
- environment.
+A: We will devote most of our resources to work on the pieces which are
+ on the critical path to release a development and execution
+ environment. Once the project is at a stage where it is useful in
+ the real world, it will achieve a critical mass of developers to
+ improve it further.
- The idea is to get Mono to a state of that would allow
- third parties to actually be able to use it real-world development.
+Q: Will Novell offer Mono commercially?
-Q: Why does Ximian even care?
+A: When Mono is ready to be shipped Ximian will offer a commercial
+ support and services for Mono. Mono components are also
+ available to be licensed commercially. For licensing details,
+ contact <a
+ href="mailto:mono-licensing@ximian.com">mono-licensing@ximian.com</a>
-A: We like the features that the CLI and its related technologies
- bring to the table. An exciting addition to the developer toolkit.
- The goal of Mono is to bring this technology to non-Windows
- platforms (although we hope Mono will also run on Windows, for
- debugging and comparative purposes).
+Q: Does Novell provide consulting services around Mono?
+A: Yes, Novell does provide consulting services around Mono to
+ make it suitable to your needs. Porting the runtime engine,
+ customizing it, working on specific classes or tuning the code
+ for your particular needs.
-** Licensing
+ Please contact <a
+ href="mailto:mono-licensing@ximian.com">mono-licensing@ximian.com</a>
+ for consulting services information.
-Q: Will I be able to write proprietary applications that run with
- Mono?
+Q: Will you wait until Mono is finished?
-A: Yes. The licensing scheme is planned to allow proprietary
- developers to write applications with Mono.
-
-Q: What license is Mono on?
+A: Mono will ship on various stages as they mature. Some people
+ require only a subset of the technologies, those will ship first,
+ see the <a href="mono-roadmap.html">Mono Roadmap</a> for details
-A: The C# Compiler is released under the terms of the GPL. The class
- libraries will be under the LGPL or the GPL with a special
- exception. The runtime libraries are under the LGPL.
+<a name="gnome"></a>
+** Mono and GNOME
- Since the LGPL is not suitable for embedded systems development, we
- are also licensing the libraries under the GPL with the following exception:
+Q: How is Mono related to GNOME?
- If you link this library against your own program, then you do not
- need to release the source code for that program. However, any
- changes that you make to the library itself, or to any native
- methods upon which the library relies, must be re-distributed in
- accordance with the terms of the GPL.
+A: In a number of ways. This project was born out of the need of
+ providing improved tools for the GNOME community, and will use
+ existing components that have been developed for GNOME when they
+ are available. For example, we plan to use Gtk+ and Libart to
+ implement Winforms and the Drawing2D API and are considering
+ GObject support.
-
This is similar in spirit to <a
- href="http://www.gnu.org/software/classpath/classpath.html">GNU
- Classpath.</a>
+
Mono team members work actively on the <a
+ href="http://gtk-sharp.sf.net">Gtk#</a> project: a binding of the
+ GNOME class libraries for .NET and Mono.
-Q: But in Object Oriented Programming I need to subclass your library
- functions, does that mean that I am making modifications to your
- library and hence I would have to distribute my sources under the
- LGPL?
+Q: Has the GNOME Foundation or the GNOME team adopted Mono?
-A: No. Object Oriented Programming in the class library is a well
- understood interface barrier, so you can actually develop
- proprietary applications with the Mono libraries.
+A: Mono is too new to be adopted by those groups. We hope that the
+ tools that we will provide will be adopted by free software
+ programmers including the GNOME Foundation members and the GNOME
+ project generally.
-Q: Will you accept code under the XXX License?
+Q: Should GNOME programmers switch over to Mono now?
-A: If the XXX License is compatible with the license we use in that
- specific piece of code, then yes. If you want to use the BSD license, make
- sure you use the BSD license without the advertisement clause (The
- `Ousterhout License').
+A: It is still far to early for discussions of "switching over." No
+ pieces of Mono will be ready within the next six months, and a
+ complete implementation is roughly one year away.
-** Mono and .NET
+ We encourage GNOME developers to continue using the existing tools,
+ libraries and components. Improvements made to GNOME will have an
+ impact on Mono, as they would be the "back-end" for various classes.
-Q: If applications use Mono, does that mean that I have to pay a service fee?
+Q: Will Mono include compatibility with Bonobo components? What is the
+ relationship between Mono and Bonobo?
-A: No. Mono is not related to Microsoft's initiative of
- software-as-a-service.
+A: Yes, we will provide a set of classes for implementing and using
+ Bonobo components from within Mono. Mono should allow you to write
+ Bonobo components more easily, just like .NET on Windows allows you
+ to export .NET components to COM.
-Q: If you implement .NET, will I depend on Microsoft Passport to run my software?
+Q: Does Mono depend on GNOME?
-A: No. The .NET Framework is a runtime infrastructure and collection
- of class libraries. Passport may be required to access certain web
- services written for that framework, but only if the programmer
- chooses Passport as the authentication mechanism.
+A: No, Mono does not depend on GNOME. We use a few packages produced by
+ the GNOME team like the `glib' library, we also use other
+ third-party open source libraries like Cairo and ICU.
-Q: Is .NET just a bunch of marketing slogans?
+Q: But will I be able to build GNOME applications?
-A: Although the `.NET initiative' is still quite nebulous, The .NET Framework
- has been available for some time. Mono is not an implementation of the .NET
- initiative, just the development framework.
+A: Yes, we will enable people to write GNOME applications using Mono.
-Q: What is a 100% .NET application?
+Q: Do you have C# bindings for GNOME?.
-A: A `100% .NET application' is one that only uses the APIs defined
- under the System namespace and does not use PInvoke. These
- applications would in theory run unmodified on Windows, Linux,
- HP-UX, Solaris, MacOS X and others.
+A: Yes, the <a href="http://gtk-sharp.sf.net">Gtk# project</a>
+ provides bindings for Gtk+, Gdk, Atk, libgnome, libgnomecanvas, and
+ libgnomeui. Other libraries under the GNOME framework will be
+ added on an as-needed (and as-requested) basis.
+
+<a name="gui"></a>
+** GUI applications
+
+Q: Will Mono enable GUI applications to be authored?
+
+A: Yes, you will be able to build GUI applications. Indeed, that is
+ our main focus. Today you can use Gtk# or #WT to develop GUI
+ applications, and support for Windows.Forms is underway.
+
+Q: What is the difference between Gtk# and System.Windows.Forms?
+
+A: Gtk# is a set of bindings for the Gtk+ toolkit for C# (and other
+ CIL-enabled languages), it integrates natively with the Gnome
+ desktop. System.Windows.Forms is an API defined by Microsoft to
+ build GUI applications.
+
+Q: What are you using to implement Windows.Forms?
+
+A: Windows.Forms is currently being implemented on top of a modified
+ version of Wine that can be used as a library: WineLib.
+
+ Essentially Wine is used as a library that happens to implement the
+ "Win32" toolkit and our Windows.Forms becomes a managed layer on
+ top of this toolkit.
+
+ There are several advantages in this approach: we get Wndproc
+ message compatibility for free (Wndproc is an overridable method in
+ the Control class and it is used to perform advanced tricks with
+ the GUI toolkit) as well as allowing third-party controls that are
+ used to P/Invoke into Win32 in the Windows world to work out of the
+ box on Linux/MacOS.
+
+Q: Why not implement System.Windows.Forms on top of Gtk# or Qt#?
+
+A: Compatibility.
+
+ Although it is possible to run simple Windows.Forms applications
+ with the Gtk#-based backend of Windows.Forms, it is very unlikely
+ that the implementation will ever implement everything needed for
+ full compatibility with Windows.Forms.
+
+ The reason is that Windows.Forms is not a complete toolkit, and to
+ work around this problem some of the underlying Win32 foundation is
+ exposed to the programmer in the form of exposing the Windows
+ message handler (WndProc). Any control can override this method.
+ Also developers often P/Invoke into Win32 to get to functionality
+ that was not wrapped.
+
+ To achieve full compatibility, we would have to emulate this, and
+ it would take too long.
+
+ For more details see the <a href="winforms.html">winforms page</a>
+
+Q: Wine applications do not look like native applications, what are
+ you going to do about this?
+
+A: We have already a few patches into our version of Windows.Forms
+ that makes Wine use the colors and font settings from your desktop,
+ improving the integration a lot. In the future, we will continue
+ to improve this interoperability scenario.
+
+Q: Will I be able to run my smart clients on systems powered by Mono?
+
+A: As long as your applications are 100% .NET and do not make use
+ of P/Invoke to call Win32 functions, your smart client applications
+ will run on Mono platforms.
+
+Q: Where can I learn more about Gtk#?
+
+A: The following <a href="http://gtk-sharp.sourceforge.net">link</a> sends you to the page of the project.
+
+Q: What can I do with Gtk#?.
+
+A: Gtk# is becoming very usable and you can create applications and
+ applets like those you see in a GNOME desktop environment. It's
+ easy to install so it's worth a try.
+
+Q: How can I compile my HelloWorld.cs which uses Gtk#?.
+
+A: Try: mcs -r:gtk-sharp HelloWorld.cs
+
+Q: Is there any way how to connect DataAdapter to some GTK# controls?
+
+A: There is a sample file called `DbClient' in gtk-sharp/samples that you
+ might to look at. It is a sample program in Gtk# that adds/updates/deletes
+ information on a Postgress database. When we have the new table/tree widgets,
+ I am sure someone would write an adapter for System.Data (in Gtk2 the
+ tree/list widgets are written using a view/model, so you only need to write
+ a model that maps to the database). You can have a look at
+ gtk-sharp/sample/DbClient, where there is a GTK# application that uses
+ System.Data. It does not use DataAdapter, but DataReader though.
+
+Q: Do you have an estimate for when Windows.Forms will be released?
+
+A: The plan currently is aimed at Q4/2004.
+
+
+Q: Do you have a comparission chart about the various toolkit
+ offerings?
+
+A: A document explaining this is available at: <a
+ href="http://primates.ximian.com/~miguel/toolkits.html">http://primates.ximian.com/~miguel/toolkits.html</a>.
+
+<a name="msft"></a>
+** Mono and Microsoft
+
+Q: Is Microsoft helping Ximian with this project?
+
+A: There is no high level communication between Ximian and Microsoft
+ at this point, but engineers who work on .NET or the ECMA groups
+ have been very friendly, and very nice to answer our questions, or
+ clarify part of the specification for us.
+
+ Microsoft is interested in other implementations of .NET and are
+ willing to help make the ECMA spec more accurate for this purpose.
+
+ Ximian was also invited to participate in the ECMA committee
+ meetings for C# and the CLI.
+
+Q: Are Microsoft or Corel paying Ximian to do this?
+
+A: No.
-Q: But Microsoft will release a port of the real thing under the
- `Shared Source' license, why bother with anything else?
+Q: Do you fear that Microsoft will change the spec and render Mono
+ useless?
-A: The Shared Source implementation will not be usable for commercial
- purposes. We are working towards an implementation that will grant
- a number of rights to recipients: use for any purpose,
+A: No. Microsoft proved with the CLI and the C# language that it was
+ possible to create a powerful foundation for many languages to
+ inter-operate. We will always have that.
+
+ Even if changes happened in the platform which were undocumented,
+ the existing platform would a value on its own.
+
+Q: Are you writing Mono from the ECMA specs?
+
+A: Yes, we are writing them from the ECMA specs and the published
+ materials in print about .NET.
+
+Q: If my applications use Mono, will I have to pay a service fee?
+
+A: No. Mono is not related to Microsoft's initiative of
+ software-as-a-service.
+
+Q: Is the Mono Project is related to the Microsoft Hailstorm effort? Is
+ Ximian endorsing Hailstorm?
+
+A: No. The Mono Project is focused on providing a compatible set of
+ tools for the Microsoft .NET development platform. It does not
+ address, require, or otherwise endorse the MS Passport-based
+ Hailstorm single sign-on system that is part of Windows XP and
+ other services.
+
+Q: Will Mono or .NET applications depend on Microsoft Passport?
+
+A: No. MS Passport is unrelated to running .NET compatible applications
+ produced with the Mono tools. The only thing you will need is a
+ just-in-time compiler (JIT).
+
+Q: If Microsoft will release a port of their .NET platform under the
+ `Shared Source' license, why should I bother with anything else?
+
+A: The Shared Source implementation will be expensive and its uses
+ will be tightly restricted, especially for commercial use. We are
+ working towards an implementation that will grant a number of
+ important rights to recipients: use for any purpose,
redistribution, modification, and redistribution of modifications.
This is what we call <a
href="http://www.gnu.org/philosophy/free-sw.html">Free Software</a>
-** Passport
-
-Q: Is this a free implementation of Passport?
+Q: Is Mono a free implementation of Passport?
-A: No. Passport is part of Microsoft's Hailstorm initiative. Mono
- is just a runtime, a compiler and a set of class libraries.
+A: No. Mono is just a runtime, a compiler and a set of class
+ libraries.
-Q: Will the System.Web.Security.PassportIdentity class, mean
+Q: Will the System.Web.Security.PassportIdentity class mean
that my software will depend on Passport?
-A: No. That just means that applications might use that API to
- contact a Passport site.
+A: No. Applications may use that API to contact a Passport site, but
+ are not required to do so.
As long as your application does not use Passport, you will not
need Passport.
- It might even be possible to implement that class with
- a set of dummy functions, or use an alternate Passport implementation.
+Q: Will Mono running on Linux make Passport available for Linux?
- We do not know at this time whether the Passport protocol is
- documented and whether we will be able to talk to
- passport.com
+A: No. However, the Passport toolkit for Linux-based web servers is
+ available from Microsoft.
-Q: What is your opinion?
+Q: Will Mono allow me to run Microsoft Office on Linux?
-A: You can read my personal <a href="passport.html">opinion on
- passport</a>.
+A: No, it will not. Microsoft Office is a Windows application. To
+ learn more about running Windows applications on Intel Unix systems
+ refer to <a href="http://www.winehq.com">the Wine Project</a>.
-** Mono and Windows
+Q: Can mono run the WebMatrix?
-Q: Will Mono allow me to run Microsoft Office on Linux?
+A: No. That requires System.Windows.Forms support which is not
+ currently implemented.
-A: No, it will not. Microsoft Office is a Windows application. To
- run Windows applications on Intel Unix systems refer to <a
- href="http://www.winehq.com">the Wine Project</a>
+Q: Does mono have something like Passport?
+ Will mono have a server side Passport/Similar framework for XSP as well as client classes?
-** GNOME
+A: Not yet, but the client side API for authentication is not the problem.
+ We will likely have a lot of other authentication APIs, like the Liberty
+ Alliance APIs. The problem is people on the web provider end that might use
+ this for authentication.
-Q: How is this related to GNOME?
+<a name="platforms"></a>
+** Mono Platforms
-A: In a number of ways:
+Q: What operating systems does Mono run on?
- * Mono will use existing
- components that have been developed for GNOME when it makes
- sense. For example on X systems, we will use Gtk+ and
- Libart to implement Winforms and the Drawing2D API.
+A: Mono is known to run on Linux, Unix and Windows systems.
- For database access, we will use LibGDA (not really
- depending on GNOME, but related to).
+Q: Can I run Mono applications without using `mono program.exe'?
- * This project was born out of the need of providing improved
- tools for the GNOME community.
+A: Yes, this is possible on Linux systems, to do this, use something like:
- * We would like to add support to our CLR implementation to
- deal with GObjects (in GNOME 1.x, they are called
- GtkObjects), and allow Mono developers to provide GObjects
- or use and extend existing GObjects.
+<pre>
+if [ ! -e /proc/sys/fs/binfmt_misc/register ]; then
+ /sbin/modprobe binfmt_misc
+ mount -t binfmt_misc none /proc/sys/fs/binfmt_misc
+fi
-Q: Has the GNOME Foundation or the GNOME team adopted Mono?
+if [ -e /proc/sys/fs/binfmt_misc/register ]; then
+ echo ':CLR:M::MZ::/usr/bin/mono:' > /proc/sys/fs/binfmt_misc/register
+else
+ echo "No binfmt_misc support"
+ exit 1
+fi
+</pre>
-A: Mono is too new to be adopted by those groups. We hope that the
- tools that we will provide will be adopted by free software
- programmers including the GNOME Foundation members and the GNOME
- project generally.
+Q: What architectures does Mono support?
-Q: Should GNOME programmers switch over to Mono?
+A: Mono today ships with a Just-in-Time compiler for x86, PowerPC and
+ SPARC-based systems. It is tested regularly on Linux, FreeBSD and
+ Windows (with the XP/NT core).
-A: Mono will not be ready even within the next six months, and a
- complete implementation is probably one year away.
+ There is also an interpreter, which is slower that runs on the
+ s390, SPARC, HPPA, StrongARM and PowerPC architectures.
- We encourage GNOME developers to continue using the existing tools,
- libraries and components. Improvements made to GNOME will have an
- impact on Mono, as they will provide the "backend" for various
- classes.
+Q: Can Mono run on Windows 9x, or ME editions?
-Q: Will Mono include compatibility with Bonobo components?
+A: Mono requires Unicode versions of Win32 APIs to run,
+ and only a handful of *W functions is supported under Win9x.
-A: Yes, we will provide a set of classes for implementing and using
- Bonobo components from within Mono.
+ There is Microsoft Layer for Unicode that provides implementation
+ of these APIs on 9x systems.
-** Mono and the Web
+ Unfortunately it uses linker trick for delayed load that is not
+ supported by ld, so some sort of adapter is necessary.
+
+ You will need MSLU and one of the following libs to link Mono to
+ unicows.dll <a
+ href="http://mono.eurosoft.od.ua/files/unimono.zip">http://mono.eurosoft.od.ua/files/unimono.zip</a>
+ or alternatively search the net for "libunicows".
-Q: Is Mono a way of running Java applets?
+ No changes to Mono source code required, the only thing is to make
+ sure that linker will resolve imports to adapter library instead of
+ Win32 libs. This is achieved by inserting -lunimono before
+ -lkerner32/user32 in the linker's specs file.
-A: No.
+Q: Why support Windows, when you can run the real thing?
+
+A: There are various reasons:
+
+ <ul>
+ <li> About half the contributors to Mono are Windows developers.
+ They have many different for contributing to the effort, and
+ we find it very important to let those developers run the runtime on Windows without forcing
+ them to use a new operating system.
+
+ <li> Supporting Windows helps us identify the portable portions
+ of Mono from the non-portable versions of it, helping Mono
+ become more portable in the future.
+
+ <li> Mono does not heavily modify the windows registry, update system DLLs,
+ install DLLs to the Windows/System32 path. Another words, I knew Mono would
+ not cause any legacy enterprise applications to stop working - and it
+ hasn't. However, our CIO er is againt it because of the changes that would
+ be made to Windows 2000, such as, affecting security.
+ </ul>
+
+<a name="compatibility"></a>
+** Compatibility
+
+Q: Can Mono run applications developed with the Microsoft.NET framework?
+
+A: Yes, Mono can run applications developed with the Microsoft .NET Framework
+ on Unix. There are a few caveats to keep in mind: Mono has not
+ been completed yet, so a few API calls might be missing; And in
+ some cases the Mono behavior *might* be incorrect.
+
+Q: Will missing API entry points be implemented?
+
+A: Yes, the goal of Mono is to implement precisely the .NET Framework
+ API (as well as compile-time selectable subsets, for those
+ interested in a lighter version of Mono).
+
+Q: If the behavior of an API call is different, will you fix it?
+
+A: Yes, we will. But we will need your assistance for this. If you find a bug
+ in the Mono implementation, please fill a bug report in <a
+ href="http://bugzilla.ximian.com">http://bugzilla.ximian.com</a>.
+ Do not assume we know about the problem, we might not, and using the bug tracking
+ system helps us organize the development process.
+
+Q: Can I develop my applications on Windows, and deploy on a supported
+ Mono platform (like Linux)?
+
+A: Yes, you can.
+ As of today, Mono is not 100% finished, so it is sometimes useful
+ to compile the code with Mono, to find out if your application
+ depends on unimplemented functionality.
+
+Q: Will applications run out the box with Mono?
+
+A: Sometimes they will. But sometimes a .NET application might invoke
+ Win32 API calls, or assume certain patterns that are not correct
+ for cross-platform applications.
+
+Q: What is a 100% .NET application?
+
+A: A `100% .NET application' is one that only uses the APIs defined
+ under the System namespace and does not use P/Invoke. These
+ applications would in theory run unmodified on Windows, Linux,
+ HP-UX, Solaris, MacOS X and others.
+
+ Note that this requirement also holds for all assemblies used by the
+ application. If one of them is Windows-specific, then the entire program
+ is not a 100% .NET application.
+
+ Furthermore, a 100% .NET application must not contain non-standard data
+ streams in the assembly. For example, Visual Studio .NET will insert a
+ <tt>#-</tt> stream into assemblies built under the "Debug" target.
+ This stream contains debugging information for use by Visual Studio .NET;
+ however, this stream can not be interpreted by Mono (unless you're willing
+ to donate support).
+
+ Thus, it is recommended that all Visual Studio .NET-compiled code be
+ compiled under the Release target before it is executed under Mono.
+
+Q: Can I execute my Visual Studio .NET program (Visual Basic .NET, Visual C#,
+ Managed Extensions for C++, etc.) under Mono?
+
+A: Yes, with some reservations.
+
+ The .NET program must either be a 100% .NET application, or (somehow) have
+ all dependent assemblies available on all desired platforms. (How to do so
+ is outside the bounds of this FAQ.)
+
+ Mono must also have an implementation for the .NET assemblies used. For
+ example the System.EnterpriseServices namespace is part of .NET, but it
+ has not been implemented in Mono. Thus, any applications using this
+ namespace will not run under Mono.
+
+ With regards to languages, C# applications tend to be most portable.
+
+ Visual Basic .NET applications are portable, but Mono's
+ Microsoft.VisualBasic.dll implementation is incomplete. It is recommended
+ to either avoid using this assembly in your own code, only use the
+ portions that Mono has implemented, or to help implement the missing
+ features. Additionally, you can set 'Option Strict On', which
+ eliminates the implicit calls to the unimplemented
+ Microsoft.VisualBasic.CompilerServices.ObjectType class.
+ (Thanks to Jörg Rosenkranz.)
+
+ Managed Extensions for C++ is least likely to operate under Mono. Mono
+ does not support mixed mode assemblies (that is, assemblies containing both
+ managed and unmanaged code, which Managed C++ can produce). You need a
+ fully-managed assembly to run under Mono, and getting the Visual C++ .NET
+ compiler to generate such an executable can be difficult. You need to use
+ only the .NET-framework assemblies, not the C libraries (you can't use
+ <b>printf</b>(3) for example.), and you need to use
+ the linker options <tt>/nodefaultlib /entry:main mscoree.lib</tt> in
+ addition to the <tt>/clr</tt> compiler flag. You can still use certain
+ compiler intrinsic functions (such as <b>memcpy</b>(3)) and the STL.
+ You should also see <a
+ href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vcmex/html/vcgrfconvertingmanagedextensionsforcprojectsfrommixed-modetopureil.asp"
+ >Converting Managed Extensions for C++ Projects from Mixed Mode to Pure
+ Intermediate Language</a> at MSDN.
+ Finally, you can use PEVERIFY.EXE from the .NET SDK to determine if the
+ assembly is fully managed.
+
+ Thanks to Serge Chaban for the linker flags to use.
+
+<a name="pnpproject"></a>
+** Mono and Portable.NET
+
+Q: What are the differences between Mono and Portable.NET?
+
+A: Most of Mono is being written using C#, with only
+ a few parts written in C (The JIT engine, the runtime, the
+ interfaces to the garbage collection system).
+
+ It is easier to describe what is unique about Mono:
+ <ul>
+ <li> An advanced native-code compilation engine: Both
+ just-in-time compilation (JIT) and pre-compilation of CIL
+ bytecodes into native code are supported.
+
+ <li> A foundation for code optimization: The new code generator in
+ Mono builds on the experience of our first JIT engine, and enables
+ us to implement various advanced compiler optimization
+ tricks. With an SSA-framework, plenty of new optimizations are possible.
+
+ The current list of optimizations are: Peephole postpass,
+ Branch optimizations, Inline method calls, Constant folding, Constant
+ propagation, Copy propagation, Dead code elimination, Linear scan
+ global reg allocation, Conditional moves, Emit per-domain code,
+ Instruction scheduling, Intrinsic method implementations, Tail
+ recursion and tail calls, Loop related optimizations, Fast x86 FP
+ compares, Leaf procedures optimizations
+
+ <li> A self-hosting C# compiler written in C#, which is clean, easy
+ to maintain.
+
+ <li> Focus on the .NET Framework: we are tracking down the .NET
+ Framework API definition, as we believe it is the API people
+ will be most familiar with.
+
+ <li> A multi-platform runtime engine: both a JIT engine and an
+ interpreter exist. The JIT engine runs currently on x86,
+ PowerPC Sparc and S390 systems, while the interpreter works on
+ x86, SPARC, StrongARM, s390 and PowerPC systems.
+
+ The JIT engine is being ported to amd64 systems as of this
+ time.
+
+ <li> Supports Linux, BSD, MacOS, Windows and Solaris at this point.
+
+ <li> The JIT engine is written using a portable instruction
+ selector which not only generates good code but
+ is also the foundation to re-target the JIT engine to other
+ systems.
+
+ <li> Full support for remoting in the runtime.
+
+ <li> The C# compiler, the JIT engine and the class libraries are
+ mature enough that the whole system has been self-hosting
+ since April 2002. This means that we develop Mono
+ completely with itself at this point.
+
+ By forcing ourselves to use our own code to develop our
+ tools, we bug fix problems rapidly, and the system is
+ overall more robust and tested than if we did not.
+
+ <li> Our class libraries are licensed under the terms of the MIT
+ X11 license which is a very liberal license as opposed to
+ the GNU GPL with exceptions, this means that Mono can be
+ used in places where the GPL with exceptions is not
+ permissible.
+
+ <li> Mono has a complete Web Services stack: we implement ASP.NET
+ web servers and web clients as well as implementing the
+ Remoting-based SOAP infrastructure.
+
+ <li> Remoting implementation: Mono has a complete remoting
+ infrastructure that is used in our own codebase to provide
+ added functionality and performance to our ASP.NET engine
+ and more.
+
+ <li> Mono has a complete <a href="c-sharp.html">C# 1.0</a>
+ implementation and has been stress tested a lot more than
+ Portable.NET's compiler.
+
+ <li> Mono's C# compiler has strong error handling and has closer
+ adherence to the specification with support for definite
+ assignment (required to generate verifiable IL code) and
+ CLS conformance checking.
+
+ <li> Mono's C# compiler is written in C# which is easier for new
+ developers to come in and improve, fix and tune. The Mono
+ C# compiler in C# is faster than their C-based compiler.
+
+ <li> Preview of C# 2.0: a work in progress for a 2.0
+ implementation of our compiler is available (iterators,
+ generics and anonymous methods are available in our
+ "preview" compiler).
+
+ <li> Mono has a complete Reflection and Reflection.Emit: these
+ are important for advanced applications, compilers and
+ dynamic code generation.
+
+ <li> Mono has a <a href="xml-classes.html">complete managed XML
+ stack</a>: XML, XPath, XML Serializer, XML Schema handling
+ are fully functional, feature complete and tuned for
+ performance.
+
+ <li> Mono has a <a href="crypto.html">complete cryptography stack
+ </a>: we implement the 1.0 and 1.1 APIs as well as using our
+ fully managed stack to implement the SSL/TLS transports.
+
+ <li> <a href="ado-net.html">Extensive database support</a>: Mono
+ ships with database provides for <a
+ href="firebird.html">Firebird</a>, <a href="ibmdb2.html">IBM
+ DB2</a>, <a href="oracle.html">Oracle</a>, <a
+ href="sybase.html">Sybase</a>, Microsoft <a
+ href="tdsclient.html">SQL Server</a>, <a
+ href="sqlite.html">SQL Lite</a>, <a
+ href="mysql.html">MySQL</a>, <a
+ href="postgresql.html">PostgresSQL</A>, <a href="oledb.html">Ole
+ DB</a> and <a href="odbc.html">ODBC</a>.
+
+ <li> Mono includes full LDAP support.
+
+ <li> We have a great community of developers, without which Mono
+ would not be possible.
+ </ul>
+
+ In general, Mono is more mature and complete since it has been used
+ to develop itself, which is a big motivator for stability and
+ correctness, while Portable.NET remains pretty much an untested
+ platform.
+
+Q: I hear Mono keeps changing the P/Invoke API, why?
+
+A: We are just fixing our implementation to be compatible with the
+ Microsoft implementation. In other words, the Mono P/Invoke API is
+ more complete when compared to the Portable.NET version, hence
+ various pieces of software that depend on this extended
+ functionality fail to work properly with Portable.NET.
+
+<a name="webservices"></a>
** Web Services
-Q: Is Mono just a new way of writing Web Services?
+Q: How is Mono related to Web Services?
-A: No.
+A: Mono is only related to Web Services in that it will implement the
+ same set of classes that have been authored in the .NET Framework
+ to simplify and streamline the process of building Web Services.
-Q: If this implements the SDK classes, will I be able to write and
- execute .NET Web Services with this?
-
-A: Yes, you will.
+ But most importantly, Mono is an Open Source implementation of the
+ .NET Framework.
+
+Q: Can I author Web Services with Mono?
- When the project is finished, you will be able to use the same
- technologies that are available through the .NET Framework SDK on
- Windows to write Web Services.
+A: You will be able to write Web Services on .NET that run on Mono and
+ vice-versa.
-Q: What about Soup?
+Q: If Mono implements the SDK classes, will I be able to write and
+ execute .NET Web Services with it?
+
+A: Yes. When the project is finished, you will be able to use the
+ same technologies that are available through the .NET Framework SDK
+ on Windows to write Web Services.
+
+Q: What about Soup? Can I use Soup without Mono?
-A: Soup is a library for GNOME applications to create SOAP server and
- SOAP clients. You can browse the source code for soup using <a
- href="http://cvs.gnome.org/bonsai">GNOME's Bonsai</a>
+A: Soup is a library for GNOME applications to create SOAP servers and
+ SOAP clients, and can be used without Mono. You can browse the
+ source code for soup using <a
+ href="http://cvs.gnome.org/bonsai/">GNOME's Bonsai</a>.
Q: Can I use CORBA?
exposing it to other RPC systems (like CORBA) is really simple, and
does not even require support from an object.
- We will be implementing CORBA interoperation as an extension to the
- Mono classes so that we can integrate with Bonobo, just like
- Microsoft provides COM interoperation classes and support
- mechanisms.
+ <a href="http://remoting-corba.sourceforge.net/">Remoting.CORBA</a> is
+ a CORBA implementation that is gaining momentum.
+
+ Building an implementation of the Bonobo interfaces once this is ready
+ should be relatively simple.
Q: Can I serialize my objects to other things other than XML?
A: Yes, although the serializing tools have not yet been planned, and
-you would probably have to implement them yourself.
+ you would probably have to implement them yourself.
+
+Q: Will Mono use ORBit?
+
+A: There are a few advantages in using ORBit, like reusing existing code
+ and leveraging all the work done on it. Michael Meeks has posted
+ a few <a href="http://lists.ximian.com/archives/public/mono-list/2002-September/008592.html">reasons</a>,
+ as well as some <a href="http://lists.ximian.com/archives/public/mono-list/2002-September/008657.html">ideas</a>
+ that could be used to reuse ORBit.
-** Development Tools
+ Most users are likely to choose a native .NET solution, like <a href="http://cvs.gnome.org/bonsai">Remoting.CORBA</a>
-Q: Will it be possible to use the CLI features without using bytecodes
- or the JIT?
+
+<a name="monodoc"></a>
+** MonoDoc
+
+Q: What is MonoDoc?
+
+A: MonoDoc is a graphical documentation browser for the Mono class
+ libraries. Currently, monodoc consists of a Gtk# application and is
+ in heavy development.
+
+<a name="devel"></a>
+** Development Tools and Issues
+
+Q: I am having trouble compiling a new version of Mono from CVS, it
+ complains about my runtime being out of sync.
+
+A: To upgrade your class libraries and compiler, see the
+ INSTALL.txt in the MCS directory.
+
+ The single biggest source of confusion seems to be the "Your
+ runtime is out of sync" messages. Realize that this is *normal*
+ while BUILDING. Think about it: you're building a new class
+ library with the old runtime. If the new class library references
+ a function that the old runtime knows nothing about, the runtime
+ system issues this warning.
+
+ Basically what needs to happen is for a new mono runtime to be
+ compiled, then the corlib class library be compiled, and once this
+ is done, install the new runtime, followed by corlib.
+
+ Once this is done, you can continue building your entire
+ environment.
+
+ For instance you just need to:
+ 1.- Upgrade your Mono runtime (you might better do it with the
+ mono-build.sh script available in the <a
+ href="http://www.go-mono.com">download</a> page.
+ 2.- Get the latest mono-lite tarball from the daily snapshots
+ <a href="http://www.go-mono.com/daily/">page</a>, unzip and
+ untar and copy all the dll files to your install path lib
+ directory (typically pointed by the $MONO_PATH variable).
+ Copy all the exe files to the install path bin directory.
+ 3.- Then checkout or update your mcs CVS copy. Then follow
+ the steps described in mcs/INSTALL.txt.
+
+Q: Will it be possible to use the CLI features without using byte codes or the JIT?
A: Yes. The CLI engine will be made available as a shared library.
The garbage collection engine, the threading abstraction, the
- object system, the dynamic type code system and the JIT will be
- available for C developers to integreate with their applications if
+ object system, the dynamic type code system and the JIT are
+ available for C developers to integrate with their applications if
they wish to do so.
Q: Will you have new development tools?
-A: Hopefully Free Software enthusiasts will contribute tools to
+A: With any luck, Free Software enthusiasts will contribute tools to
improve the developer environment. These tools could be developed
- initially using Microsoft implementation of the CLI and then
+ initially using the Microsoft implementation of the CLI and then
executed later with Mono.
+ We are recommending people to use and contribute to existing
+ projects like SharpDevelop, Anjuta and Eclipse.
+
+Q: What kind of rules make the Common Intermediate Language useful for
+ JITers?
+
+A: The main rule is that the stack in the CLI is not a general purpose
+ stack. You are not allowed to use it for other purposes than
+ computing values and passing arguments to functions or return
+ values.
+
+ At any given call or return instruction, the types on the stack
+ have to be the same independently of the flow of execution of your
+ code.
+
+Q: Is it true that the CIL is ideal for JITing and not efficient for
+ interpreters?
+
+A: The CIL is better suited to be JITed than JVM byte codes, but you
+ can interpret them as trivially as you can interpret JVM byte
+ codes.
+
+Q: Isn't it a little bit confusing to have the name of "XSP" (the same
+ as in the Apache Project) for the ASP.NET support in Mono?.
+
+A: In Mono, xsp is just the name of the C# code generator for ASP.NET
+ pages. In the Apache Project, it is a term for the "eXtensible Server
+ Pages" technology so as they are very different things, they don't
+ conflict.
+
+Q: Is there any plan to develop an aspx server for Mono?.
+
+A: The XSP reference server is available and you can also use mod_mono
+ with Apache.
+
+Q: Is there any way I can develop the class libraries using Linux yet?
+
+A: Yes. Mono has been self hosting since May 2002.
+
+Q: Is there any way I can install a known working copy of mono in /usr,
+ and an experimental copy somewhere else, and have both copies use
+ their own libraries? (I'm still not very good at library paths in
+ Linux)
+
+A: Yes. Just use two installation prefixes.
+
+Q: How should I write tests or a tests suite?
+
+A: If you do a test suite for C#, you might want to keep it
+ independent of the Mono C# compiler, so that other compiler
+ implementations can later use it.
+
+Q: Would it be too terrible to have another corlib signed as mscorlib?
+
+A: We rename corlib to mscorlib also when saving the PE files, in fact,
+ the runtime can execute program created by mono just fine.
+
+Q: Is it possible to build a C# file to some sort of intermediate format which
+ can linked into a final module, like the traditional .c -> .o -> .so path?
+
+A: You can use:
+
+ mcs /target:library file1.cs, mcs /target:library file2.cs,
+ mcs /target:exe file1.dll file2.dll /out:mybin.exe
+
+Q: Is there any plans for implementing remoting in the near future?
+
+A: The remoting infrastructure is in place. We have implementations
+ of the TcpChannel, HttpChannel and the Soap and Binary Formatters.
+ They are compatible with .NET.
+
+ However, some classes from the library may have a different binary
+ representation, because they may have a different internal data
+ structure, so for example you won't be able to exchange a Hastable
+ object between Mono and MS.NET. It should not be a problem if you
+ are using primitive types, arrays or your own classes. In any case,
+ could you post a test case?
+
+
+Q: My C code uses the __stdcall which is not availble on Linux, how can I
+ make the code portable Windows/Unix across platforms?
+
+A: Replace the __stdcall attribute with the STDCALL macro, and include this
+ in your C code for newer gcc versions:
+
+ #ifndef STDCALL
+ #define STDCALL __attribute__((stdcall))
+ #endif
+
+Q: I want to be able to execute Mono binaries, without having to use the "mono"
+ command. How can I do this?
+
+A: From Carlos Perelló:
+
+ <i>I think that the best solution is the binfmt feature with the
+ wrapper that exists with Debian packages at:
+
+ <a href="http://www.debianplanet.org/mono/dists/unstable/main/source/admin/">http://www.debianplanet.org/mono/dists/unstable/main/source/admin/</a>
+
+ If you want use it with Big endian machines, you should apply a patch
+ (<a href="http://carlos.pemas.net/debian/mono/binfmt-detector-cli.c.diff">http://carlos.pemas.net/debian/mono/binfmt-detector-cli.c.diff</a>)
+
+ It works really good and lets you use wine also, it reads the .exe file
+ headers and check if it's a .net executable.
+
+ This way you just execute: ./my-cool-mono-application.exe and it works
+ without the need of any wrapper.</i>
+
+Q: I see funny characters when I run programs, what is the problem?
+
+A: (From Peter Williams and Gonzalo Paniagua):
+
+ This is Red Hat 9 (probably) using UTF8 on its console; the bytes are
+ the UTF8 endianness markers. You can do:
+
+ LC_ALL=C mono myexe.exe
+
+ And they wont show up.
+
+ Alternatively, you can do:
+
+ $ echo -e "\033%G"
+
+ to enable UTF-8 on the console.
+
+<a name="asp">
+** Mono and ASP.NET
+
+Q: Does Mono support ASP.NET?
+
+A: Yes.
+
+ Mono supports ASP.NET, we have shown an unmodified IBuySpy
+ installation running on Mono as well as various other programs. You can
+ try it yourself downloading the XSP server.
+
+Q: Do I need install cygwin to work on ASP.NET in mono or Linux is enough since
+ it is self host right now.
+
+A: Linux is enough.
+
+Q: How can I run ASP.NET-based applications with Mono?
+
+A: You need the Mono runtime and a hosting web server. Currently we distribute a
+ small web server called `xsp' which is used to debug applications, or you can choose
+ to use Daniel's Apache 2 module.
+
+Q: Any plan to make ASP.NET in mono works with Apache in Linux?.
+
+A: Daniel has authored an Apache2 Module for Mono that hosts the ASP.NET runtime
+ and is available here: <a
+ href="http://apacheworld.org/modmono/">http://apacheworld.org/modmono/</a>
+
+Q: Will you support Apache 1?
+
+A: Modules developed for Apache 2 are not compatible with Apache 1.3
+ Daniel plans to support Apache 1.3 in the future but the current focus is on
+ Apache 2, because of the better support for threading and Windows.
+
+Q: Can I run Apache 1 and Apache 2 on the same machine?
+
+ You can always keep a copy of Apache 2 running in parallel with your Apache
+ 1.3 (either different port or using a reverse proxy).
+
+ You can also bind the two servers to different IP addresses on the
+ same physical machine.
+
+<a name="ado">
+** Mono and ADO.NET
+
+Q: What is the status of ADO.NET support?. Could I start migrating
+ applications from MS.NET to Mono?.
+
+A: You could start right now using the ADO.NET support in mono, of course,
+ if you want to help filling the missing gaps while you develop your app
+ :-) Well, what I mean is that we're not that far to having full ADO.NET
+ support in Mono, and we've got a lot of working things, so if we could
+ get more help, we'd finish it really soon :-)
+
+Q: In developing the data architecture for the application are there and
+ objects I should stay away from in order to insure the smoothest possible
+ transition (minimum code rewrite) to Mono's ADO.NET implementation? (For
+ example, strongly typed datasets versus untyped datasets, etc...)
+
+A: We are implementing all the classes in Microsoft .NET's System.Data, so
+ you can be sure that things will work the same in Mono as with the Microsoft
+ implementation.
+
+Q: Does Mono can to connect to Sybase by using Mono.Data.*?
+
+A: Yes. use Mono.Data.SybaseClient. First of all you have to create a
+ SybaseConnection, and then, from it, use it as any other
+ IDbConnection-based class.
+
+<a name="java">
** Mono and Java
-Q: What about using Java? After all there are many languages that
+Q: Why don't you use Java? After all, there are many languages that
target the Java VM.
A: You can get very good tools for doing Java development on free
systems right now. <a href="http://www.redhat.com">Red Hat</a> has
contributed a <a href="http://gcc.gnu.org">GCC</a> <a
- href="http://gcc.gnu.org/java">frontend for Java</a> that can take
+ href="http://gcc.gnu.org/java/">front-end for Java</a> that can take
Java sources or Java byte codes and generate native executables; <a
- href="http://www.transvirtual.com">Transvirtual</a> has implemented
+ href="http://www.google.com/search?q=transvirtual">Transvirtual</a>
+ implemented
<a href="http://www.kaffe.org">Kaffe</a> a JIT engine for Java;
Intel also has a Java VM called <a
- href="http://www.intel.com/research/mrl/orp">ORP</a>.
+ href="http://www.intel.com/research/mrl/orp/">ORP</a>.
The JVM is not designed to be a general purpose virtual machine.
The Common Intermediate Language (CIL), on the other hand, is
wide variety of programming languages, and has a set of rules
designed to be optimal for JITers.
+Q: Could Java target the CLI?
-Q: What kind of rules make the Common Intermediate Language useful for
- JITers?
+A: Yes, Java could target the CLI, Microsoft's J# compiler does that.
-A: The main rule is that the stack in the CLI is not a general purpose
- stack. You are not allowed to use it for other purposes than
- computing values and passing arguments to functions or return
- values.
+ The <a href="http://weblog.ikvm.net/">IKVM</a> project builds a
+ Java runtime that works on top of .NET and on top of Mono. IKVM is
+ essentially a JIT compiler that translates from JVM bytecodes into
+ CIL instructions, and then lets the native JIT engine take over.
- At any given call or return instruction, the types on the stack
- have to be the same independently of the flow of execution of your
- code.
+Q: Is it possible to write a JVM byte code to CIL converter?
-Q: I heard that the CIL is ideal for JITing and not efficient for
- interpreters, is this the case?
+A: Yes, this is what <a href="http://weblog.ikvm.net">IKVM</a> does.
-A: The CIL is better suited to be JITed than JVM byte codes, but you
- can interpret them as trivially as you can interpret JVM byte
- codes.
+Q: Could mono become a hybrid CIL/java platform?
+
+A: This can be obtained easily with IKVM.
+
+Q: Do you plan to implement a Javascript compiler?
+
+A: Yes. The beginnings of the JScript compiler can be found on CVS.
+ Cesar coordinates this effort.
+
+Q: Can Mono or .NET share system classes (loaded from mscore.dll and other
+ libs) or will it behave like Sun's Java VM?
+
+A: What you can do with mono is to load different applications in their own
+ application domain: this is a feature of the CLR that allows sandboxing
+ applications inside a single process space. This is usualy exploited to
+ compartmentalize different parts of the same app, but it can also be
+ effectively used to reduce the startup and memory overhead.
+ Using different appdomains the runtime representation of types and
+ methods is shared across applications.
+<a name="extending"></a>
** Extending Mono
Q: Would you allow other classes other than those in the
For more information on extending Mono, see our <a
href="ideas.html">ideas</a> page.
-** Mono and portability
+Q: Do you plan to Embrace and Extend .NET?
+
+A: Embracing a good technology is good. Extending technologies in
+ incompatible ways is bad for the users, so we do not plan on
+ making incompatible changes to the technologies.
+
+ If you have innovative ideas, and want to create new classes, we
+ encourage you to make those classes operate correctly well in both
+ Mono and .NET.
+
+ Today Mono ships with a number of extra libraries that were
+ developed either by members of the Mono community, or other
+ groups.
+
+ In some cases, we have found the bits from Microsoft to be
+ incomplete, but we avoid breaking the API, instead we expose the
+ missing functionality in new assemblies (See Mono.Security and
+ System.Security).
+
+Q: Is there any way I can develop the class libraries using Linux yet?
+
+A: Yes. Mono has been selfhosting since March 2002.
+
+Q: Is there any way I can install a known working copy of mono in /usr,
+ and an experimental copy somewhere else, and have both copies use
+ their own libraries? (I'm still not very good at library paths in
+ Linux)
+
+A: Yes. Just use two installation prefixes.
+
+
+<a name="portability"></a>
+** Portability
Q: Will Mono only work on Linux?
Windows. We do not expect many Linux-isms in the code, so it
should be easy to port Mono to other UNIX variants.
-Q: What about Mono on non X-based systems?
+Q: What about Mono on non Linux-based systems?
A: Our main intention at Ximian is to be able to develop GNOME
applications with Mono, but if you are interested in providing a
- port of the Winform classes to other platforms (frame buffer or
+ port of the Winforms classes to other platforms (frame buffer or
MacOS X for example), we would gladly integrate them, as long
- they are under a Free Software License.
+ they are under an open source license.
-** Reusing existing Code
+Q: What operating systems/CPUs do you support
-Q: What projects will you reuse or build upon?
+A: Mono currently runs on Linux, Windows, Solaris, FreeBSD, HP-UX and
+ MacOS X.
-A: We want to get Mono in the hands of programmers soon. We are
- interested in reusing existing open source software.
+ There is a JIT engine available for x86 processors that can
+ generate code and optimizations tailored for a particular CPU.
-Q: What about Intel's research JIT framework, ORP?
+ Interpreters exist for the SPARC v8, SPARC v9, Itanium, HP-PA,
+ PowerPC and StrongARM CPUs.
-A: At this time, we are investigating whether we can use elements of
- ORP for Mono. ORP is a research JIT engine that has a clear
- defined API that splits the JIT from the GC system and the actual
- byte code implementation. It is a research product.
+Q: Does Mono run on Windows?
-Q: What about using GNU Lightning?
+A: Yes. You can get pre-compiled
+ binaries from <a href="http://www.go-mono.com/download.html">http://www.go-mono.com/download.html</a>
-A: We are also researching <a
- href="http://www.gnu.org/software/lightning/lightning.html">GNU
- Lightning</a>.
+Q: Does Mono run on Linux?
-<a name="ximian-and-microsoft">
-** Ximian and Microsoft
+A: Yes. You can get pre-compiled
+ binaries from <a href="http://www.go-mono.com/download.html">http://www.go-mono.com/download.html</a>
-Q: I read that Microsoft is helping out Ximian, is this true?
+Q: Will I require Cygwin to run mono?
-A: Initial contact between David Stutz and Miguel de Icaza happened.
- It was a friendly conversation. Microsoft is interested in other
- implementing .NET and are willing to help make the ECMA spec more
- accurate for this purpose.
+A: No. Cygwin is only required to build Mono.
- We were initially contacted by Sam Ruby at the ECMA TG3 committee
- to discuss the same issue. And we are glad to have good contacts
- to ask questions about the specs.
+Q: Will Mono depend on GNOME?
+
+A: It will depend only if you are using a particular assembly (for
+ example, for doing GUI applications). If you are just interested
+ in Mono for implementing a `Hello World Enterprise P2P Web
+ Service', you will not need any GNOME components.
-Q: Do you fear that Microsoft will change the spec and render Mono useless?
+Q: Do you plan to port Rhino to C#?.
-A: No. Microsoft proved with the CLI and the C# language that it was
- possible to create a powerful foundation for many languages to
- interoperate. We will always have that.
+A: Eto Demerzal has started a Rhino port to C#.
- Even if changes happened in the platform which were undocumented
- (which is very unlikely), the existing platform has a value on its
- own.
+Q: Has anyone succeeded in building a Mac version of the C# environment.
+ If so can you explain how?
- Miguel once explained its motivation for working on Mono to Dave
- Winer, and his mail got posted <a
- href="http://scriptingnews.userland.com/stories/storyReader$1275">here</a>
+A: Yes, Mono works on Linux/PPC and MacOS X (10.2 and 10.3)
-Q: Didn't Miguel de Icaza say that `Unix Sucks'?
+<a name="reuse"></a>
+** Reusing Existing Code
-A: Yes, he did, as a catch phrase in his opening remark on the Ottawa
- Linux Symposium. His talk focused on various ways to improve Unix.
+Q: What projects will you reuse or build upon?
- There is a paper describing some ways to improve Unix at:
+A: We want to get Mono in the hands of programmers soon. We are
+ interested in reusing existing open source software.
- <a href="http://primates.ximian.com/~miguel/bongo-bong.html">
- http://primates.ximian.com/~miguel/bongo-bong.html</a>
+Q: Will I be able to use Microsoft SQL Server 2000 or will I need to switch
+ to a specific Open Source Database. Will I need to recode?
-Q: Didn't Ximian's Miguel work for Microsoft?
+A: There is no need to rewrite your code as long as you keep using
+ Microsoft SQL Server. If you want to use an open source database,
+ you might need to make changes to your code.
-A: Actually, Nat Friedman (Ximian's co-founder) did work as an
- intern for Microsoft for one summer but Miguel did not.
+Q: What do I need to watch out for when programming in VB.NET so that I'm
+ sure to be able to run those apps on Linux?
-Q: Did Nat and Miguel meet at Microsoft?
+A: Not making any P/Invoke or DLL calls should and not using anything in
+ the Microsoft.* namespaces should suffice. Also do not use any
+ Methods/Classes marked as "This type/method supports the .NET Framework
+ infrastructure and is not intended to be used directly from your code."
+ even if you know what these classes/methods do.
-A: They met online on the Linux IRC network; They met in person for
- the first time in 1997.
+Q: Will built-in reporting be supported for crystal reports? This is a
+ heavily used part of our system.
-** Mono and Microsoft
-
-Q: How can you expect Mono to compete with Microsoft, wont this
- require an effort too large?
+A: . Crystal Reports are propriety. Someone may try to emulate
+ the behavior, but no-one has yet volunteered.
-A: You are right. Mono will never become a reality without the help
- of other contributors. Ximian is a small company that can not
- finish Mono alone. We will be working with members of the
- community to deliver the product.
+Q: Who about writing to the registry? As I understand it, Linux does not have
+ a counterpart to the registry. Should I avoid relying on that feature?
-Q: Is Microsoft and Corel involved in the Mono implementation?
+A: Try to avoid it. Although there would be a emulation for registry in
+ Mono too. GNOME does have a registry like mechanism for configuration. But
+ Even if gnome has a configuration system similar to the registry, the keys
+ will not be equal, so you will probably end up having to do some runtime
+ detection, and depending on this load an assembly that has your
+ platform-specific hacks.
-A: No, they are not.
+Q: System.Data.SqlClient with FreeTDS, will you port parts of these to C# and
+ use them?
-Q: Are you writing Mono from the ECMA specs?
+A: This has been done.
-A: yes, we are writing them from the ECMA specs and the published
- materials in print about .NET
+<a name="gcc"></a>
+** Mono and GCC
-** Acronyms
+Q: Are you working on a GCC front-end to C#?
-Q: What is the difference between CLR (Common Language Runtime) and
- CLI (Common Language Infrastructure)?
+A: We are not working on a GCC front-end for C#
-A: CLI is the specification of an execution system. The Microsoft
- implementation of this specification is named CLR.
+Q: Will you support C/C++ on the Mono VM?
- Unless we come up with our own acronym, we could just call ours
- also CLR, just because it would do exactly the same thing the
- Microsoft implementation does.
+A:The open64 compiler effort from SGI helps a lot in this direction.
-<a name="gcc">
-** Mono and GCC
+ The Open64 compiler is a modified version of GCC that
+ generates a new intermediate language instead of RTL. This could be
+ the foundation to generate CIL code, and to implement the upcoming
+ Managed extensions to C++ from ECMA.
-Q: Should someone work on a GCC front-end to C#?
+ Open64 (and other derivative forks of GCC) split the gcc front-ends
+ from the backends by using the WHIRL intermediate representation.
+ Kris has begun the implementation of a translator from WHIRL to CIL.
-A: I would love if someone does, and we would love to help anyone that
- takes on that task, but we do not have the time or expertise to
- build a C# compiler with the GCC engine. I find it a lot more fun
- personally to work on C# on a C# compiler, which has an intrinsic
- beauty.
+ So it will be possible to use the GCC compilers to target the CIL.
-Q: Should someone make a GCC backend that will generate CIL images?
+Q: What about Managed C++?
-A: I would love to see a backend to GCC that generates CIL images. It
- would provide a ton of free compilers that would generate CIL
- code. This is something that people would want to look into
- anyways for Windows interoperation in the future.
+A: Once a full translator for WHIRL exists, we are interested in
+ looking at expanding the GCC frontends to include extensions for
+ Managed C++.
Q: What about making a front-end to GCC that takes CIL images and
generates native code?
-A: I would love to see this, specially since GCC supports this same
- feature for Java Byte Codes. You could use the metadata library
- from Mono to read the byte codes (ie, this would be your
- "front-end") and generate the trees that get passed to the
- optimizer.
+A: There is no active work on this area, but Mono already provides
+ pre-compilation services (Ahead-of-Time compilation).
- Ideally our implementation of the CLI will be available as a shared
- library that could be linked with your application as its runtime
- support.
-Q: But would this work around the GPL in the GCC compiler and allow
- people to work on non-free front-ends?
+<a name="performance"></a>
+** Performance
-A: People can already do this by targeting the JVM byte codes (there
- are about 130 compilers for various languages that target the JVM).
+Q: How fast will Mono be?
-Q: Why are you writing a JIT engine instead of a front-end to GCC?
+A: We can not predict the future, but a conservative estimate is that
+ it would be at least `as fast as other JIT engines'.
-A: The JIT engine and runtime engine will be able to execute CIL
- executables generated on Windows.
+ Mono's JIT engine has been recently re-architected, and it provides
+ many new features, and layers suitable for optimization. It is
+ relatively easy to add new optimizations to Mono.
-** Mono and GNU
+ The CIL has some advantages over the Java byte code: The existance
+ of structs in addition to classes helps a lot the performance and
+ minimizes the memory footprint of applications.
-Q: Is Mono part of the GNU project?
+ Generics in the CLI world are first-class citizens, they are not
+ just a strong-typing addition to the language. The generic
+ specifications are embedded into the instruction stream, the JIT
+ uses this information to JIT a unique instances of a method that is
+ optimized for the type arguments.
-A: Mono is a Ximian project. It is also part of the GNU project.
+ The CIL is really an intermediate representation and there are a
+ number of restrictions on how you can emit CIL code that simplify
+ creating better JIT engines.
-** Mono and Portability
+ For example, on the CIL, the stack is not really an abstraction
+ available for the code generator to use at will. Rather, it is a
+ way of creating a postfix representation of the parsed tree. At
+ any given call point or return point, the contents of the stack are
+ expected to contain the same object types independently of how the
+ instruction was reached.
-Q: Will Mono work on other variants of Unix?
+<a name="licensing"></a>
+** Licensing
-A: Yes. We do not expect to add any gratuitous incompatibilities.
+Q: Will I be able to write proprietary applications that run with
+ Mono?
-Q: Will Mono run on Windows?
+A: Yes. The licensing scheme is planned to allow proprietary
+ developers to write applications with Mono.
+
+Q: What license or licenses are you using for the Mono Project?
+
+A: The C# Compiler is released under the terms of the <a
+ href="http://www.opensource.org/licenses/gpl-license.html">GNU GPL</a>. The runtime
+ libraries are under the <a
+ href="http://www.opensource.org/licenses/lgpl-license.html">GNU
+ Library GPL</a>. And the class libraries are released
+ under the terms of the <a
+ href="http://www.opensource.org/licenses/mit-license.html">MIT X11</a>
+ license.
+
+ The Mono runtime and the Mono C# Compiler are also available under
+ a proprietary license for those who can not use the LGPL and the
+ GPL in their code.
+
+ For licensing details, contact <a
+ href="mailto:mono-licensing@ximian.com">mono-licensing@ximian.com</a>
+
+
+Q: I would like to contribute code to Mono under a particular
+ license. What licenses will you accept?
+
+A: We will have to evaluate the licenses for compatibility first,
+ but as a general rule, we will accept the code under the same
+ terms of the "container" module.
+
+<a name="patents"></a>
+** Patents
+
+Q: Could patents be used to completely disable Mono (either submarine
+ patents filed now, or changes made by Microsoft specifically to
+ create patent problems)?
+
+A: First some background information.
+
+ The .NET Framework is divided in two parts: the ECMA/ISO covered
+ technologies and the other technologies developed on top of it like
+ ADO.NET, ASP.NET and Windows.Forms.
+
+ Mono implements the ECMA/ISO covered parts, as well as being a
+ project that aims to implement the higher level blocks like
+ ASP.NET, ADO.NET and Windows.Forms.
+
+ The Mono project has gone beyond both of those components and has
+ developed and integrated third party class libraries, the most
+ important being: Debugging APIs, integration with the Gnome
+ platform (Accessibility, Pango rendering, Gdk/Gtk, Glade, GnomeUI),
+ Mozilla, OpenGL, extensive database support (Microsoft only
+ supports a couple of providers out of the box, while Mono has
+ support for 11 different providers), our POSIX integration
+ libraries and finally the embedded API (used to add scripting to
+ applications and host the CLI, or for example as an embedded
+ runtime in Apache).
+
+ The core of the .NET Framework, and what has been patented by
+ Microsoft falls under the ECMA/ISO submission. Jim Miller at
+ Microsoft has made a statement on the patents covering ISO/ECMA,
+ (he is one of the inventors listed in the patent): <a
+ href="http://web.archive.org/web/20030609164123/http://mailserver.di.unipi.it/pipermail/dotnet-sscli/msg00218.html">here</a>.
+
+ Basically a grant is given to anyone who want to implement those
+ components for free and for any purpose.
+
+ The controversial elements are the ASP.NET, ADO.NET and
+ Windows.Forms subsets. Those are convenient for people who need
+ full compatibility with the Windows platform, but are not required
+ for the open source Mono platform, nor integration with today's
+ Mono's rich support of Linux.
+
+ The Mono strategy for dealing with these technologies is as
+ follows: (1) work around the patent by using a different
+ implementation technique that retains the API, but changes the
+ mechanism; if that is not possible, we would (2) remove the pieces
+ of code that were covered by those patents, and also (3) find prior
+ art that would render the patent useless.
+
+ Not providing a patented capability would weaken the
+ interoperability, but it would still provide the free software /
+ open source software community with good development tools, which
+ is the primary reason for developing Mono.
-A: Hopefully yes. Currently some parts of Mono only run on Windows
- (the C# compiler is a .NET executable) and other parts have only
- been compiled on Linux, but work on Windows with Cygwin.
+ The patents do not apply in countries where software patents are
+ not allowed.
-Q: Will Mono depend on GNOME?
+ For Linux server and desktop development, we only need the ECMA
+ components, and things that we have developed (like Gtk#) or Apache
+ integration.
-A: It will depend only if you are using a particular assembly (for
- example, for doing GUI applications). If you are just interested
- in Mono for implementing a `Hello World Enterprise P2P Web
- Service', you will not need any GNOME component.
+Q: Is Mono only an implementation of the .NET Framework?
-** Performance
+A: Mono implements both the .NET Framework, as well as plenty of class
+ libraries that are either Unix specific, <a
+ href="http://www.gnome.org">Gnome</a> specific, or that are not
+ part of the .NET Framework but people find useful.
-Q: How fast will be Mono?
+ The following map shows the relationship between the components:
-A: We can not predict the future, but a conservative estimate is that
- it would be at least `as fast as other JIT engines'.
+ <img src="http://primates.ximian.com/~miguel/tmp/map.png">
- Now, wishfully thinking I hope that we will ship various JITs with
- Mono just like Microsoft has done. A fast JITer when maximum
- performance is not needed, but fast load times are important; And
- an optimizing JITer that would be slower at generating code but
- produce more optimal output.
-
- The CIL has some advantages over the Java byte code: it is really
- an intermediate representation and there are a number of
- restrictions on how you can emit CIL code that simplify creating
- better JIT engines.
-
- For example, on the CIL the stack is not really an abstraction
- available for the code generator to use at will: it is just a way
- of creating a postfix representation of the parsed tree. At any
- given call point or return point, the contents of the stack are
- expected to contain the same object types independently of how the
- instructions was reached.
+<a name="obfuscation"></a>
+** Obfuscation
+
+Q: Are there any obfuscation programs for Mono/Linux?
+
+A: We are not aware of these, but some from Windows might work.
+
+Q: What could I do to avoid people decompiling my program?
+
+A: You can use the bundle functionality in Mono.
+
+ This would bundle your binary inside a Mono runtime instance, so
+ you distribute a single executable that contains the code inside.
+ Notice that for this to work and be practical, you need to get a
+ commercial license to the Mono runtime.
+
+ The reason is that the bundle functionality is covered by the LGPL:
+ so you would have to distribute your assemblies separatedly to allow
+ developers to relink mono which would defeat the purpose of bundling
+ for obscuring your code.
-** Assorted questions
+ It is not impossible to break, just like any other obfuscators.
+
+ That being said, value these days does not lie in particular
+ tiny routines, but lies in the large body of work, and if someone
+ steals your code, you are likely going to find out anyways.
+
+Q: Any other option?
+
+A: You could precompile with --aot your code, then disassemble the
+ original .exe, and remove all the code, then re-assemble and ship
+ both the vessel .exe and the precompiled code.
+
+ This is not a supported configuration of Mono, and you would be
+ on your own in terms of dealing with bugs and problems here.
+
+ Get the companies that build the obfuscation packages to read
+ the ECMA spec and fix the bugs in their products that generate
+ non-standard binaries (or, if they expose a bug in mono, please
+ file a report in our bugzilla).
+
+ Pay Ximian/Novell to spend the development time needed to get mono
+ to support the broken binaries that some of the obfuscation
+ packages generate (or contribute that support).
+
+<a name="etc"></a>
+** Miscellaneous Questions
Q: You say that the CLI allows multiple languages to execute on the
same environment. Isn't this the purpose of CORBA?
-A: CORBA can be used for this purpose, but think of CORBA mostly as a
- inter-process (local machine or remote machine) communication
- system.
+A: The key difference between CORBA (and COM) and the CLI is that the
+ CLI allows "data-level interoperability" because every
+ language/component uses the same data layout and memory management.
- Think of the CLI to be targeted to interoperation of languages in
- the same process, and CORBA as being a nifty addition for
- out-of-process.
+ This means you can operate directly upon the data types that someone
+ else provides, without having to go via their interfaces. It also
+ means you don't have to "marshal" (convert) parameters (data
+ layouts are the same, so you can just pass components directly) and
+ you don't have to worry about memory management, because all
+ languages/components share the same garbage collector and address
+ space. This means much less copying and no need for reference
+ counting.
- Sure, we have used CORBA for in-proc components, but the lack of an
- ABI for in-proc components does not translate into a good framework
- for in-proc systems
+Q: Will you support COM?
-
+A: The runtime will support XPCOM on Unix systems and COM on Windows.
+ Most of the code for dynamic trampolines exists already.
+
+Q: Will Ximian offer certifications on Mono or related technologies?.
+
+A: It's possible. But there is no plan about this. So the short answer is no.
+
+Q: How can I report a bug?
+
+A: The best thing is to track down the bug and provide a simple test
+ to reproduce the bug. You can then add the bug to our bug tracking
+ system. You can use our <a href="bugs.html">Bug Form</a> to enter
+ bugs for the appropriate component.
+
+ Please provide information about what version of mono you're using
+ and any relevant details to be able to reproduce the bug. Note that
+ bugs reported on the mailing-list may be easily forgotten, so it's
+ better to file them in the <a href="http://bugzilla.ximian.com/enter_bug.cgi">bug tracking system</a>.
+
+Q: Does mcs support the same command line options as the MS C#
+ compiler?
+
+A: The Mono C# compiler now supports the same command line
+ arguments as the Microsoft C# compiler does.
+
+Q: How about getting searchable archives on lists.ximian.com?
+
+A: You can perform a search on the mono-related mailing lists
+ <a href="http://www.go-mono.com/mailing-lists.html">here</a>.
+
+Q: When using mono from cvs or from a snapshot, I get an error messaage
+ saying that Mono and the runtime are out of sync. How do I fix that?
+
+A: If you use mono from cvs, you need to be prepared for changes in the
+ runtime internals. This means that you should keep a working setup
+ before blindling updating (a working setup may just be the last released
+ tarball or a recent binary snapshot).
+ Usually, compiling corlib with mcs before recompiling the C runtime does
+ the right thing (but occasionally you may need to do it the other
+ way around).
+
+Q: Why are you going for a GtkHtml implementation?
+
+A: GtkHTML is just a lightweight HTML rendering engine that does not
+ support CSS, so we need it to look decent for those of us that will
+ be using the documentation in our day-to-day work on Linux. The
+ Web-based interfaces lack the agility that you get from a native GUI
+ tool to browse your documentation. Probably later on, we will write
+ scripts and generate a full documentation set that is web-browsable,
+ but we need a command-line and GUI tools that we can use natively on
+ Linux when disconnected from the Web (and that has better
+ interactions than a web page).
+
+Q: Is there a command-line tool that allows me to access .NET interactively?
+
+A: There are several but one that is free software and uses MCS is the one
+ Dennis Lu from Rice University is working on; a REPL C# interpreter.
+
+Q: Is it possible to use Visual C++ with Mono?.
+
+A: It's possible to run VC++ generated apps under Mono, but we do not
+ provide a Manager C++ compiler ourselves.
+
+Q: Does Mono support generics?.
+
+A: Yes, the Mono runtime now supports the new Generics extensions, and
+ there is also support for generics in our new compiler: `gmcs'.
+
+ The Mono C# 1.0 compiler (mcs) will ship with various C# 2.0
+ features, but generics will remain on the separate compiler (gmcs)
+ as this code is not as tested as the main compiler.
+
+<a name="problems"></a>
+** Mono Common Problems
+
+ If you are having problems compiling or running Mono software
+ or if you think that you found a bug, etc. Please visit the
+ <a href="http://monoevo.sf.net/mono-common-problems.html">Mono Common Problems</a> document and try there.
+
+** Credits
+ The FAQ contains material contributed by Miguel de Icaza, Jaime Anguiano, Lluis Sánchez.
projects / mono.git / blobdiff