The Abstraction Project - Static Language Framework

  •        44

The Abstraction Project, Written in C#, is focused towards helping language enthusiasts write a compiler on top of the .NET Common Language Infrastructure.



Related Projects

graal - Java Bytecodes to OpenCL Code Generation using the Graal JIT Compiler

Java Bytecodes to OpenCL Code Generation using the Graal JIT Compiler

PA5 - compiler program assignment (code generation)

compiler program assignment (code generation)

OpenTuringCompiler - A cross platform Turing Compiler built with LLVM.

A compiler for Turing written using LLVM for code generation and Dparser for parsing. 10x faster than the most popular implementation and cross-platform.Unfortunately abandoned because although I have the resources to debug a compiler (with all the common features) I don't have the time to implement the thousand library methods present in regular Turing (though I made an effort and this compiler implements hundreds). The other issue is that Turing is a learning language where the possibility of compiler bugs would be devastating to the confidence of newbies, and it takes years to fully debug a compiler.


CodeCommander is a code generator and makes it easier for developers to construct a source code. You'll no longer have to write your source code twice a week. It's developed in C# .NET V2.0


ETP-Basic Compiler is a cross compiler. It takes in entry a basic-like language and generates m68k assembler. The compiler can be executed on a x86 platform, and the source can be compiled by Visual Studio or g++. In the future, the code generation can be accodomated for TI nspire calculators.

spaghetti - Type-safe APIs for compile-to-JavaScript modules

Spaghetti modules are written in compile-to-JS languages like [TypeScript]( and [Haxe]( Each module's API is defined in a [Spaghetti Interface Definition file](/../../wiki/Spaghetti Syntax). Here's an example of a typical API definition:```module com.example.greeterinterface Greeter { string sayHello(string user)}Greeter createGreeter()```Based on this abstract definition, Spaghetti ensures type safety on both the implementor and the caller side of a


A variant of OCaml's native code compiler ocamlopt using LLVM in the back-end for optimization and code generation. Warning: Binaries produced by this compiler are in no way compatible with binaries produced by ocamlopt.

Babel - The compiler for writing next generation JavaScript

Babel is the compiler for writing next generation JavaScript.


A simple MinC to MIPS intermediate code compiler. This project will include the intermediate code generation without general type checking. We are to assume that the MinC code will be semantically correct.

grpc-swift - The Swift language implementation of gRPC.

This repository contains an experimental Swift gRPC API and code generator.It is intended for use with Apple's swift-protobuf support for Protocol Buffers. Both projects contain code generation plugins for protoc, Google's Protocol Buffer compiler, and both contain libraries of supporting code that is needed to build and run the generated code.

Draak Compiler

Draak is a multi-language, macro compiler, meaning all syntax and code generation is defined in a single file. Draak is a single binary that is able to compile any context free language (like C, Pascal, Java) for any platform with only 1 file.

Jurassic - A Javascript Compiler for .NET

Jurassic is an implementation of the ECMAScript language and runtime. It aims to provide the best performing and most standards-compliant implementation of JavaScript for .NET.

[Ex] Vczh Library++

A general purpose script engine platform for hosting scripting languages of multiple levels, with a set of predefined script languages and a library for building new script languages. Also, linq on C++ and a high level string processing library(including regex) are provided.

colfer - binary serialization format

Colfer is a binary serialization format optimized for speed and size.The project's compiler colf(1) generates source code from schema definitions to marshal and unmarshall data structures.

protoc-gen-haxe - Protocol Buffers compiler and run-time library for Haxe

I am also the author of [protoc-gen-as3](,which is the best Protocol Buffers implementation in ActionScript 3.I rewritten these code because I want to try the Haxe way to generate code.This table lists main difference between `protoc-gen-as` (or any other Protocol Buffers implementation) and `protoc-gen-haxe`:| | protoc-gen-as3 | protoc-gen-haxe || ------------- | ------------- | ----- || Cross-platform | No. It only runs in Adobe Flash Player or Adobe A


Dingo is a pluggable Schema Compiler for .NET and will generate C# code. The goal is to provide a simple way to generate Domain Objects. .NET XSD currently only generates Data Objects. Dingo can delegate code generation with high granularity.


OILexer is a LL parser generator for C# aimed at simple language parsing for language enthusiasts. Does not use recursive descent or bottom-up parsing methods, but rather, a top-down deterministic model is employed. This is a portion of the Abstraction Project.

Hierarchical State Machine Compiler

This projects helps you to easily create and generate hierarchical state machine in .NET. States, transitions, conditions, action, states inheritance


This repo contains LLILC, an LLVM based compiler for .NET Core. It includes a set of cross-platform .NET code generation tools that enables compilation of MSIL byte code to LLVM supported platforms.

oc - An experimental, next-generation, coroutine-based, modular compiler for a subset of ooc.

An experimental, next-generation, coroutine-based, modular compiler for a subset of ooc.