DotGNU ideas list: Summer of Code

The DotGNU project is a Free Software implementation of the .NET and Mono platforms and spans many different programming areas: from low-level tasks like code generators to compilers, to class libraries and GUI applications.

If you want to modify or extend these tasks or have your own ideas, please see the GNU Project guidelines for Summer of Code projects. If you want to discuss potential projects with the DotGNU team, we'd love to talk to you about it. You can contact us by email on the DotGNU mailing list, or by IRC on the or #dotgnu channels on

Tasks for Portable.Net class library, engine or compilers

  1. Fill the gaps in Portable.NET's System.Windows.Forms (Complexity: medium)

    The Portable .NET Windows.Froms library implements much of .NET 1.1, but some classes are still missing or not completely implemented.

  2. Complete generics or add any other C# 2.0, 3.0 feature. (Complexity: high)

    For example add support for lambda/anonymous methods and the yield statement. The Portable .NET C# compiler is based on bison, flex and the treecc tool.

  3. Work on memory leaks, implement a special feature in the Garbage Collector. (Complexity: high)

    It would be beneficial to have a method in GC which can enumerate all objects which reference a specified object. The signature of this method might be, for example, object[] GC.GetReferences( object o ).

  4. Replacing CIL with native code. (Complexity: high)

    DotGNU contains a code generator that can be used for Just-in-Time compilation at runtime. Code can also be compiled ahead of time to produce native code before it's needed. The goal is to modify the runtime and compilation so that the bytecodes can be safely removed from a program and a single image is shipped containing both metadata and native code.

Tasks for libjit (The just-in-time compiler used by Portable.Net

The Portable .NET implements Just-In-Time compilation functionality. Unlike other JIT's, libJIT (a reusable JIT library) is designed to be independent of any particular virtual machine bytecode format or language. If you run Portable .NET on a machine for which a native code generator is not yet available, then Portable .NET will fall back to interpreting the code.

Read the libjit rationale for instruction and rationale for the DotGNU JIT Library (libJIT).

  1. Add support for reading and writing shared libraries from JIT'ed code (Complexity: medium-high)

    Complete ELF reader and writer.
    You can also add support for any other storage/container format (PECOFF for example). You'll have to add the infrastructure for handling relocations too.

  2. Port libJIT to a new architecture or improve existing architecture support (Complexity: medium-high)

    You could port libJIT to a new architecture, for example PPC, OpenRISC, SPARC, MIPSEL and so on or improve an existing code generator (alpha, ...). The libJIT manual describes the steps needed to for porting libJIT to new architectures.

  3. Enhance libJIT optimization (Complexity: medium-high)

    For example, implement inlining, enhance constant propagation or dead-code elimination.

  4. Implement DWARF3 exception handling support (Complexity: high)

    Make libjit exceptions interoperable with gcc's C++ exceptions. One possible solution might be integration of libunwind

Back to