Mono(Mono 1.0)                                                                                             Mono(Mono 1.0)

NAME
       mono - Mono’s ECMA-CLI native code generator (Just-in-Time and Ahead-of-Time)

SYNOPSIS
       mono [options] file [arguments...]

DESCRIPTION
       mono  is  a  runtime  implementation of the ECMA Common Language Infrastructure.  This can be used to run ECMA and
       .NET applications.

       The runtime contains a native code generator that transforms the Common Intermediate Language into native code.

       The code generator can operate in two modes: just in time compilation (JIT) or ahead of  time  compilation  (AOT).
       Since code can be dynamically loaded, the runtime environment and the JIT are always present, even if code is com‐
       piled ahead of time.

       The runtime loads ths specified file and optionally passes the arguments to it.  The file  is  an  ECMA  assembly.
       They typically have a .exe or .dll extension.

       The  runtime  provides  a number of configuration options for running applications, for developping and debugging,
       and for testing and debugging the runtime itself.

RUNTIME OPTIONS
       The following options are available:

       --aot  This option is used to precompile the CIL code in the specified assembly to  native  code.   The  generated
              code  is stored in a file with the extension .so.  This file will be automatically picked up by the runtime
              when the assembly is executed.

              Ahead-of-Time compilation is most useful if you use it in combination with the  -O=all,-shared  flag  which
              enables  all  of  the optimizations in the code generator to be performed.  Some of those optimizations are
              not practical for Just-in-Time compilation since they might be very time consuming.

              Unlike the .NET Framework, Ahead-of-Time compilation will not generate domain independent code:  it  gener‐
              ates  the  same  code  that the Just-in-Time compiler would produce.   Since most applications use a single
              domain, this is fine.   If you want to optimize the generated code for use  in  multi-domain  applications,
              consider using the -O=shared flag.

 Manual page mono(1) line 1