DotGnu

=[|DotGNU Project] - [|.GNU Freedom for the Net] =

Free Software for Webservices and for C# Programming
The DotGNU project aims to be for webservices and for C# programs what GNU/Linux is rapidly becoming for desktop and server applications: the industry leader and provider of [|Free Software] solutions. DotGNU currently consists of three main development projects ([|further components will be added over time]):
 * [|DotGNU Portable.NET], an implementation of the Common Language Infrastructure (CLI), more commonly known as ".NET", includes everything that you need to compile and run C# and C applications that use the base class libraries, XML, and Systems.Windows.Forms. Currently supported CPUs: x86, ppc, arm, parisc, s390, ia64, alpha, mips, sparc. Supported operating systems: GNU/Linux (on PCs, Sparc, iPAQ, Sharp Zaurus, PlayStation 2, Xbox,...), *BSD, Cygwin/Mingw32, Mac OS X, Solaris, AIX. [|[Intro]] [|[Download]] [|[Install]]
 * [|phpGroupWare], a multi-user web-based GroupWare suite, which also serves to provide a good collection of webservice components, all of which can be accessed through XML-RPC so that you can easily integrate them into webservice applications of your own.
 * The [|DGEE] webservice server is also moving forward nicely. [|[Intro]] [|[Download]] [|[Install]]

Major motivations for being involved in DotGNU include:
 * A desire to prevent Microsoft from achieving their stated goal "that the era of 'open computing,' the free exchange of digital information that has defined the personal computer industry, is ending". [|Read the quotation in context and learn how the Free Software movement works to prevent this disaster]. The contribution of the DotGNU project might turn out to be important.
 * A technical interest in webservices, bytecode systems, and compiler construction.
 * A business strategy of using DotGNU, and contributing to DotGNU. DotGNU is part of [|GNU] and thereby protected from coming under the control of any single company.

=[|DotGNU Portable.NET]= The goal of DotGNU Portable.NET is to build a suite of Free Software tools to compile and execute applications for the Common Language Infrastructure (CLI), which is often referred to as ".NET". The initial target platform was GNU/Linux, but DotGNU Portable.NET has been known to work under Windows, NetBSD, FreeBSD, Solaris, and MacOS X, amongst others. It also runs on a variety of CPUs including x86, PPC, ARM, Sparc, s390, Alpha, ia-64, and PARISC.

Focus on Compatibility
DotGNU Portable.NET is focused on compatibility with the [|ECMA-334] and [|ECMA-335] specifications for C# and CLI, and with Microsoft's commercial CLI implementation. Our main goal is to make it easy to write portable application programs which work well both on DotGNU Portable.NET and on Microsoft's .NET platform. In addition, we want to make sure that many application programs which were written for Microsoft's .NET platform (with no consideration for portability) will work well with DotGNU on many operating systems.

Installing
DotGNU Portable.NET can be installed either from a [|binary package] or from [|source code] (recommended). Once you have installed DotGNU Portable.NET, you may want to install [|DGEE]. Also, check out the [|demo and sample programs].

Runtime engine
The runtime engine in DotGNU Portable.NET, called "ilrun", is used to interpret programs in the Common Intermediate Language (CIL) bytecode format, described in the [|ECMA-335] specifications. Because interpreting CIL bytecode directly is quite inefficient, we take a different approach. We first convert the CIL bytecode into a simpler instruction set for what we call the Converted Virtual Machine (CVM). The simpler CVM instructions are then executed using a high-performance interpreter. A description of the CVM instruction set can be found here. The CVM approach gives us many of the benefits of a Just-In-Time compiler (JIT), in that the opcodes can be tailored to handle system differences (e.g. 32-bit vs 64-bit CPU's). At the same time, the engine's source code is highly portable to new platforms. As another optimization on some CPU's (currently x86 and ARM), we further translate CVM opcodes into native machine code for direct execution. This gives an additional performance improvement with only a small coding effort required. We will eventually write a full JIT for DotGNU Portable.NET, but we are currently focused on completeness and stability. See the file "pnet/engine/HACKING" in the source code for further information on the structure of the runtime engine.

The license
The 'ilrun' runtime engine is made available under the terms of the GNU General Public License (GPL), the 'pnetlib' class library under the terms of the GPL with a "linking exception" which allows you to link application programs with pnetlib regardless of what license has been chosen for your application program. In other words, the "linking exception" causes the GPL to only extend to the C# library's API boundaries and then stop there.

Compiler
The DotGNU Portable.NET compiler, cscc, is a modular compiler system with good support for the C# and C programming languages. Work on support for some other languages (Java and VB.NET) has been started. The C# front-end implements the [|ECMA C# Language Specification ECMA-334]. The C language front-end implements ANSI C. Implementing additional languages is aided significantly by the innovative "Tree Compiler Compiler" (treecc) program, which uses aspect-oriented programming techniques to manage the complexity of compiler construction. See the treecc documentation for more information on this tool. The compiler is designed to support bytecode generation for multiple bytecode systems. The current bytecode back-end supports the Common Language Infrastructure (CLI) defined by[|ECMA C# Language Specification ECMA-335]. Other back-ends to support the Java Virtual Machine (JVM) and the Perl 6 Parrot engine are in progress. (Note however that the JVM lacks sufficient instructions to run C code, so cscc will never be able to compile C to the JVM.)

System.Windows.Forms
An advantage of our implementation of System.Windows.Forms is that we don't try to wrap up third party widget sets like Gtk, Qt, Wine, etc. Instead, we provide a basic drawing layer and then render the controls ourselves. The approach is similar to Java Swing, in that all controls are implemented in pure C#. This approach should allow us to emulate the Windows visual appearance and behavior more closely and portably than other approaches because we don't need to work around the quirks in foreign toolkits. Our implementation has been known to run on x86, PPC, and ARM based GNU/Linux systems, as well as Mac OS X. See the DotGNU Web site for current screenshots. The DotGNU Portable.NET Forms implementation is structured into three layers, which are found in the source directories System.Drawing, System.Drawing/Toolkit, and System.Windows.Forms. System.Drawing provides the basic drawing functionality, emulating the Windows GDI layer as faithfully as possible. When drawing to a control, use the definitions in System.Drawing.Graphics. System.Drawing/Toolkit defines an interface to primitive drawing toolkits. Toolkits provide simple line/text/etc drawing (IToolkitGraphics), plus a simple window mechanism (IToolkitWindow). There may be multiple toolkits in the system, each providing drawing functionality in a different manner. The current toolkits include System.Drawing.Xsharp, which wraps around the DotGNU Portable.NET Xsharp library; and System.Drawing.Win32, which wraps up the native Win32 API under Windows. System.Windows.Forms builds upon the primitive drawing and window facilities from System.Drawing and System.Drawing/Toolkit to implement the various controls, forms, dialogs, etc, that are defined by the Forms API. The file "pnetlib/System.Windows.Forms/HACKING" in the source code contains more information on developing for our implementation of System.Windows.Forms. We are looking for volunteers to help us finish the System.Windows.Forms implementation, and are offering cash prizes. See the [|competition] page for more details.

Further information
For further information on DotGNU Portable.NET, please refer to the [|FAQ of the Portable.Net development project]. "Latest Changes" information with information on source code packages released by the project is available [|here].