Project Description
Reflective# is a project which consists of two main features:
A programming language, called Reflective#, which aims for full integration with other .NET languages, and full reflection features (and self modification), along with many utilities and easy-to-use advanced features.
An AOT Compiler for CLR assemblies, translating them to native code (win pe and elf) for performance optimization and portability.

The Reflective# Programming Language:

The main goals of the language are to have full reflection features (including self modification),
add some syntatic sugars and remove some redundancies of C#,
extend the dynamic functionality, and have a big standard library with lots of advanced integrated features.
Reflective# is not exactly a superset of C#, because some keywords have some different meanings,
but most C# programs will compile and run under the Reflective# environment with little or no modification.

Example:
using System;
using Refl; //the main namespace of the standard library

namespace Test
{
    public class Foo
    {
        public static void Main(string[] args)
        {
            Bar.Write("I'm on my own thread!");
            Bar.FooBar(); //Prints "original" to the console

            //Changes the method at runtime
            Bar.FooBar = { Console.WriteLine("Modified!"); };

            Bar.FooBar(); //prints "Modified!" to the console

            Bar.BuildModifications();
            //saves the modifications to the executable (or dll)
            // After that, the class is permanently modified,
            // and if the same executable is run again
            // the first call to Bar.FooBar() will print "Modified!".
        }
    }
    // The reflective keyword here indicates that the class
    // can be modified and saved at runtime.
    public reflective class Bar
    {
        //this is a threaded method. It is always called in a new thread of its own.
        public static threaded void Write(string a)
        {
            Console.WriteLine(a);
        }
        public static void FooBar()
        {
            Console.WriteLine("original");
        }
    }
}

The Documentation is already well structured and with lots of useful information, take a look and discover Reflective#.

Suggested Articles:
Dreaming
Multithreading
Roadmap
Implementations

The Reflective# AOT Compiler:

It consists in a translator which generates C++ mixed with NASM code from an specified IL assembly.
Note: This development section hasn't started yet, so we have no functionality at all.

Last edited Feb 18, 2012 at 7:19 PM by matheus2740, version 27