Microsoft's Common Language Runtime (CLR) is a very tempting platform
for executing RPython.  For one thing, as it is installed by default
on recent Windows machines and it can runs also on Linux thanks to
Mono \cite{Mono}, it is one of the most widely available
virtual machines in existence;  In addition, the CLR was designed from
the beginning to host many different languages, and contains a wide variety of features.

At its core the CLR is a stack machine.  The types of values that it can manipulate are described by the the Common Type Specification, or CTS, and can be broken into two basic categories: reference and value types.  Reference types are objects allocated on the heap.  Value types, however, are allocated on the stack and passed by value.  These include both built-in primitive types, such as integers and floating-point numbers, and user-defined types similar to C \verb"struct"s.  Value types can be converted into reference types if needed by \emph{boxing} them; meaning to place a copy of the value in the heap.

At load time CLR code is subject to some form of checking. Programs that  
are intended to pass the verification checks are said to written in  
verifiable code.  The code generated by GenCLI is verifiable, in fact it  
conforms to the following requirements: 
\begin{itemize}
\item all dynamically allocated memory data are managed data, i.e., all  
objects are allocated from the garbage collected heap, and are  
self-describing. 
 
\item Operations on data are generated in such a way that the verifier is  
able to prove that they are safe for the types of the  
operands. 

\item Arguments of method calls are conformant to the statically specified  
method signature in term of number and type of parameters.
\end{itemize}

One important feature of the CLR which RPython makes use of is generic typing.  As of version 2.0, the CLR allows both reference and values types, as well as their methods, to be parameterized by other types.  For example, a list object might be parameterized by the type of object which it contains.  Whenever an instance of a generic type is created, a set of concrete type-parameters must be supplied as well; so, considering our parameterized list, it would not be possible to simply create a List object.  Instead, we could create a list of strings, or some other type.  The CLR dynamically clones the generic type definition as needed to match the concrete type-parameters.  This cloning process allows generic types to be instantiated with either primitive or reference types as desired.