Updated: 03/2008 Mono(Mono 1.0) Mono(Mono 1.0)


      mono  -  Mono's ECMA-CLI native code generator (Just-in-Time and Ahead-


      mono [options] file [arguments...]


      mono is a runtime implementation of the ECMA  Common  Language  Infras‐
      tructure.  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 dynami‐
      cally loaded, the runtime environment and the JIT are  always  present,
      even if code is compiled ahead of time.
      The  runtime  loads  the specified file and optionally passes the argu‐
      ments 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 developing and debugging, and for testing and  debug‐
      ging the runtime itself.


      On  Unix-based  systems,  Mono provides a mechanism to emulate the Win‐
      dows-style file access, this includes providing a case insensitive view
      of  the  file  system,  directory  separator  mapping (from \ to /) and
      stripping the drive letters.
      This functionality is enabled by  setting  the  MONO_IOMAP  environment
      variable to one of all, drive and case.
      See the description for MONO_IOMAP in the environment variables section
      for more details.


      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 combi‐
             nation 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  compila‐
             tion since they might be very time consuming.
             Unlike  the  .NET  Framework, Ahead-of-Time compilation will not
             generate domain independent code: it  generates  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 applica‐
             tions, consider using the -O=shared flag.
             This pre-compiles the methods,  but  the  original  assembly  is
             still  required to execute as this one contains the metadata and
             exception information which is not available  on  the  generated
             file.   When  precompiling  code, you might want to compile with
             all optimizations (-O=all).  Pre-compiled code is position inde‐
             pendent code.
             Pre  compilation  is  just  a  mechanism to reduce startup time,
             increase code sharing across multiple mono processes  and  avoid
             just-in-time  compilation  program  startup costs.  The original
             assembly must still be present, as  the  metadata  is  contained
             For   more   information   about   AOT,   see:  http://www.mono-
      --config filename
             Load the specified configuration file  instead  of  the  default
             one(s).  The default files are /etc/mono/config and ~/.mono/con‐
             fig or the file specified in the MONO_CONFIG  environment  vari‐
             able,  if  set.   See the mono-config(5) man page for details on
             the format of this file.
             Configures the virtual machine to be better suited  for  desktop
             applications.   Currently  this  sets  the  GC  system  to avoid
             expanding the heap as much as possible at the expense of slowing
             down garbage collection a bit.
      --help , -h
             Displays usage instructions.
      --optimize=MODE , -O=MODE
             MODE  is  a  comma  separated  list of optimizations.  They also
             allow optimizations to be turned off by prefixing the  optimiza‐
             tion name with a minus sign.
             The following optimizations are implemented:
                          all        Turn on all optimizations
                          peephole   Peephole postpass
                          branch     Branch optimizations
                          inline     Inline method calls
                          cfold      Constant folding
                          consprop   Constant propagation
                          copyprop   Copy propagation
                          deadce     Dead code elimination
                          linears    Linear scan global reg allocation
                          cmov       Conditional moves
                          shared     Emit per-domain code
                          sched      Instruction scheduling
                          intrins    Intrinsic method implementations
                          tailc      Tail recursion and tail calls
                          loop       Loop related optimizations
                          fcmov      Fast x86 FP compares
                          leaf       Leaf procedures optimizations
                          aot        Usage of Ahead Of Time compiled code
                          precomp    Precompile all methods before executing Main
                          abcrem     Array bound checks removal
                          ssapre     SSA based Partial Redundancy Elimination
                          sse2       SSE2 instructions on x86
             For example, to enable all the optimization but dead code elimi‐
             nation and inlining, you can use:
             Mono supports  different  runtime  versions.  The  version  used
             depends on the program that is being run or on its configuration
             file (named program.exe.config). This  option  can  be  used  to
             override such autodetection, by forcing a different runtime ver‐
             sion to be used. Note that this should only be used to select  a
             later  compatible  runtime  version than the one the program was
             compiled against. A typical usage is for running a  1.1  program
             on a 2.0 version:
                      mono --runtime=v2.0.50727 program.exe
      --security , --security=mode
             Activate  the security manager, a currently experimental feature
             in Mono and it is OFF by default.
             Using security without parameters is equivalent  as  calling  it
             with the "cas" parameter.
             The following modes are supported:
             cas    This   allows   mono   to  support  declarative  security
                    attributes, e.g. execution of Code Access Security  (CAS)
                    or non-CAS demands.
                    Enables  the core-clr security system, typically used for
                    Moonlight/Silverlight applications.  It provides  a  much
                    simpler  security  system  than CAS, see http://www.mono-
           for more details and links  to  the
                    descriptions of this new system.
             Configures  the  virtual  machine to be better suited for server
             operations (currently, a no-op).
      -V , --version
             Prints JIT version information  (system  configuration,  release
             number and branch names if available).


      The following options are used to help when developing a JITed applica‐
             Turns on the debugging mode in the runtime.  If an assembly  was
             compiled with debugging information, it will produce line number
             information for stack traces.
             Turns on profiling.  For more information about profiling appli‐
             cations and code coverage see the sections "PROFILING" and "CODE
             COVERAGE" below.
             Shows method names as they are invoked.  By default all  methods
             are traced.
             The  trace  can  be  customized  to  include or exclude methods,
             classes or assemblies.  A trace expression is a comma  separated
             list  of  targets, each target can be prefixed with a minus sign
             to turn off a particular target.  The words `program', `all' and
             `disabled'  have  special meaning.  `program' refers to the main
             program being executed, and `all' means all the method calls.
             The `disabled' option is used to start up with tracing disabled.
             It  can  be  enabled  at a later point in time in the program by
             sending the SIGUSR2 signal to the runtime.
             Assemblies are specified by their name, for  example,  to  trace
             all calls in the System assembly, use:
                  mono --trace=System app.exe
             Classes are specified with the T: prefix.  For example, to trace
             all calls to the System.String class, use:
                  mono --trace=T:System.String app.exe
             And individual methods are referenced with the  M:  prefix,  and
             the standard method notation:
                  mono --trace=M:System.Console:WriteLine app.exe
             As previously noted, various rules can be specified at once:
                  mono --trace=T:System.String,T:System.Random app.exe
             You  can  exclude  pieces, the next example traces calls to Sys‐
             tem.String except for the System.String:Concat method.
                  mono --trace=T:System.String,-M:System.String:Concat
             Finally, namespaces can be specified using the N: prefix:
                  mono --trace=N:System.Xml


      The maintainer options are only used by those  developing  the  runtime
      itself, and not typically of interest to runtime users or developers.
      --break method
             Inserts  a  breakpoint  before the method whose name is `method'
             (namespace.class:methodname).  Use  `Main'  as  method  name  to
             insert a breakpoint on the application's main method.
             Inserts  a  breakpoint  on exceptions.  This allows you to debug
             your application with a native debugger  when  an  exception  is
      --compile name
             This compiles a method (, this is used
             for testing the compiler performance or to examine the output of
             the code generator.
             Compiles  all  the methods in an assembly.  This is used to test
             the compiler performance or to examine the output  of  the  code
      --graph=TYPE METHOD
             This  generates  a postscript file with a graph with the details
             about the specified  method  (   This
             requires  `dot'  and  ghostview  to  be  installed  (it  expects
             Ghostview to be called "gv").
             The following graphs are available:
                       cfg        Control Flow Graph (CFG)
                       dtree      Dominator Tree
                       code       CFG showing code
                       ssa        CFG showing code after SSA translation
                       optcode    CFG showing code after IR optimizations
             Some graphs will only be available if certain optimizations  are
             turned on.
             Instruct  the  runtime  on  the  number of times that the method
             specified by --compile (or all the methods  if  --compileall  is
             used) to be compiled.  This is used for testing the code genera‐
             tor performance.
             Displays information about the work done by the  runtime  during
             the execution of an application.
             Perform maintenance of the process shared data.
             semdel will delete the global semaphore.
             hps will list the currently used handles.
      -v , --verbose
             Increases the verbosity level, each time it is listed, increases
             the verbosity level to include more information (including,  for
             example,  a disassembly of the native code produced, code selec‐
             tor info etc.).


      The mono runtime includes a profiler that can be used to explore  vari‐
      ous  performance related problems in your application.  The profiler is
      activated by passing the --profile command line argument  to  the  Mono
      runtime, the format is:
      Mono  has a built-in profiler called 'default' (and is also the default
      if no arguments are specified), but developers can write custom profil‐
      ers, see the section "CUSTOM PROFILERS" for more details.
      If a profiler is not specified, the default profiler is used.
      The profiler_args is a profiler-specific string of options for the pro‐
      filer itself.
      The default profiler accepts the following options 'alloc'  to  profile
      memory consumption by the application; 'time' to profile the time spent
      on each routine; 'jit' to collect time spent JIT-compiling methods  and
      'stat' to perform sample statistical profiling.  If no options are pro‐
      vided the default is 'alloc,time,jit'.
      By default the profile data is printed to stdout: to change  this,  use
      the 'file=filename' option to output the data to filename.
      For example:
           mono --profile program.exe

      That  will  run  the program with the default profiler and will do time
      and allocation profiling.

           mono --profile=default:stat,alloc,file=prof.out program.exe
      Will do  sample statistical profiling and allocation profiling on  pro‐
      gram.exe. The profile data is put in prof.out.
      Note  that  the statistical profiler has a very low overhead and should
      be the preferred profiler to use (for better output use the  full  path
      to  the  mono  binary when running and make sure you have installed the
      addr2line utility that comes from the binutils package).


      There are a number of external profilers that have been  developed  for
      Mono, we will update this section to contain the profilers.
      The  heap  Shot  profiler can track all live objects, and references to
      these objects, and includes a GUI tool, this is  our  recommended  pro‐
      filer.  To install you must download the profiler from Mono's SVN:
           svn co svn://
           cd heap-shot
           make install
      See the included documentation for details on using it.
      The  Live  Type  profiler  shows  at every GC iteration all of the live
      objects of a given type.   To install you must  download  the  profiler
      from Mono's SVN:
           svn co svn://
           cd heap-prof
           make install
      To use the profiler, execute:
           mono --profile=desc-heap program.exe
      The output of this profiler looks like this:
           Checkpoint at 102 for heap-resize
              System.MonoType : 708
              System.Threading.Thread : 352
              System.String : 3230
              System.String[] : 104
              Gnome.ModuleInfo : 112
              System.Object[] : 160
              System.Collections.Hashtable : 96
              System.Int32[] : 212
              System.Collections.Hashtable+Slot[] : 296
              System.Globalization.CultureInfo : 108
              System.Globalization.NumberFormatInfo : 144
      The  first line describes the iteration number for the GC, in this case
      checkpoint 102.
      Then on each line the type is displayed as well as the number of  bytes
      that are being consumed by live instances of this object.
      The  AOT  profiler is used to feed back information to the AOT compiler
      about how to order code based on the access patterns for pages.  To use
      it, use:
           mono --profile=aot program.exe
      The  output of this profile can be fed back into Mono's AOT compiler to
      order the functions on the disk to produce precompiled images that have
      methods in sequential pages.


      Mono  provides a mechanism for loading other profiling modules which in
      the form of shared libraries.  These profiling modules can hook  up  to
      various  parts of the Mono runtime to gather information about the code
      being executed.
      To use a third party profiler you must pass the name of the profiler to
      Mono, like this:
           mono --profile=custom program.exe

      In  the  above sample Mono will load the user defined profiler from the
      shared library `'.  This profiler module must be
      on your dynamic linker library path.
      A list of other third party profilers is available from Mono's web site
      Custom profiles are written as shared libraries.   The  shared  library
      must be called `' where `NAME' is the name of your
      For a sample of how to write your own custom profiler look in the  Mono
      source tree for in the samples/profiler.c.


      Mono  ships  with  a code coverage module.  This module is activated by
      using  the  Mono  --profile=cov  option.    The   format   is:   --pro‐
      file=cov[:assembly-name[/namespace]] test-suite.exe
      By default code coverage will default to all the assemblies loaded, you
      can limit this by specifying the assembly name, for example to  perform
      code coverage in the routines of your program use, for example the fol‐
      lowing command line limits the code coverage to routines in the  "demo"
           mono --profile=cov:demo demo.exe

      Notice that the assembly-name does not include the extension.
      You  can  further  restrict  the  code  coverage output by specifying a
           mono --profile=cov:demo/My.Utilities demo.exe

      Which will only perform code coverage in the given assembly and  names‐
      Typical output looks like this:
           Not covered: Class:.ctor ()
           Not covered: Class:A ()
           Not covered: Driver:.ctor ()
           Not covered: Driver:method ()
           Partial coverage: Driver:Main ()
                offset 0x000a

      The offsets displayed are IL offsets.
      A  more  powerful  coverage  tool is available in the module `monocov'.
      See the monocov(1) man page for details.


      It is possible to obtain a stack trace of all  the  active  threads  in
      Mono  by sending the QUIT signal to Mono, you can do this from the com‐
      mand line, like this:
           kill -QUIT pid
      Where pid is the Process ID of the Mono process you  want  to  examine.
      The  process  will  continue  running  afterwards, but its state is not
      Important: this is a last-resort mechanism for  debugging  applications
      and  should  not  be used to monitor or probe a production application.
      The integrity of the runtime after sending this signal is  not  guaran‐
      teed  and  the  application might crash or terminate at any given point
      You can use the MONO_LOG_LEVEL and MONO_LOG_MASK environment  variables
      to get verbose debugging output about the execution of your application
      within Mono.
      The MONO_LOG_LEVEL environment variable if set, the  logging  level  is
      changed  to  the  set  value.  Possible values are "error", "critical",
      "warning", "message", "info", "debug". The default  value  is  "error".
      Messages  with  a  logging level greater then or equal to the log level
      will be printed to stdout/stderr.
      Use "info" to track the dynamic loading of assemblies.

      Use the MONO_LOG_MASK environment variable to limit the extent  of  the
      messages  you  get:  If  set, the log mask is changed to the set value.
      Possible values are "asm"  (assembly  loader),  "type",  "dll"  (native
      library  loader), "gc" (garbage collector), "cfg" (config file loader),
      "aot" (precompiler) and "all".  The default value  is  "all".  Changing
      the mask value allows you to display only messages for a certain compo‐
      nent. You can use multiple masks by comma separating them. For  example
      to  see  config file messages and assembly loader messages set you mask
      to "asm,cfg".
      The following is a common use to track down problems with P/Invoke:
           $ MONO_LOG_LEVEL="debug" MONO_LOG_MASK="dll" mono glue.exe


      Mono's XML serialization engine by default will use a  reflection-based
      approach  to  serialize  which  might be slow for continuous processing
      (web service applications).  The serialization  engine  will  determine
      when a class must use a hand-tuned serializer based on a few parameters
      and if needed it will produce a customized C# serializer for your types
      at  runtime.   This  customized serializer then gets dynamically loaded
      into your application.
      You can control this with the MONO_XMLSERIALIZER_THS environment  vari‐
      The  possible  values  are  `no'  to disable the use of a C# customized
      serializer, or an integer that is the minimum number of uses before the
      runtime will produce a custom serializer (0 will produce a custom seri‐
      alizer on the first access, 50 will produce a serializer  on  the  50th
      use). Mono will fallback to an interpreted serializer if the serializer
      generation somehow fails. This behavior can be disabled by setting  the
      option `nofallback' (for example: MONO_XMLSERIALIZER_THS=0,nofallback).


             Turns off the garbage collection in Mono.  This should  be  only
             used for debugging purposes
             If  set,  this variable will instruct Mono to ahead-of-time com‐
             pile new assemblies on demand and store the result into a  cache
             in ~/.mono/aot-cache.
             If set, this variable overrides the default system configuration
             directory ($PREFIX/etc).  It's  used  to  locate  machine.config
             If  set,  this variable overrides the default runtime configura‐
             tion file ($PREFIX/etc/mono/config). The --config  command  line
             options overrides the environment variable.
             If  set,  enables some features of the runtime useful for debug‐
             ging.  This variable should contain a comma  separated  list  of
             debugging  options.   Currently,  the following options are sup‐
                    Collects information about  pagefaults.    This  is  used
                    internally to track the number of page faults produced to
                    load metadata.  To display this information you must  use
                    this option with "--stats" command line option.
                    Captures  the interrupt signal (Control-C) and displays a
                    stack trace when pressed.  Useful to find out  where  the
                    program  is  executing  at a given point.  This only dis‐
                    plays the stack trace of a single thread.
                    This option will leak delegate trampolines  that  are  no
                    longer referenced as to present the user with more infor‐
                    mation about a delegate  misuse.   Basically  a  delegate
                    instance  might be created, passed to unmanaged code, and
                    no references kept in managed code,  which  will  garbage
                    collect  the  code.   With  this option it is possible to
                    track down the source of the problems.
                    If this variable is set, when the Mono  VM  runs  into  a
                    verification problem, instead of throwing an exception it
                    will break into the debugger.  This is useful when debug‐
                    ging verifier problems
             If  set, tells mono NOT to attempt using native asynchronous I/O
             services. In that case, a default select/poll implementation  is
             used. Currently only epoll() is supported.
             If  this  environment variable is `yes', the runtime uses unman‐
             aged collation (which actually means no culture-sensitive colla‐
             tion).  It  internally  disables managed collation functionality
             invoked  via  the  members  of  System.Globalization.CompareInfo
             class. Collation is enabled by default.
             For platforms that do not otherwise have a way of obtaining ran‐
             dom bytes this can be set to the name of a file system socket on
             which an egd or prngd daemon is listening.
             Sets  the type of event log provider to use (for System.Diagnos‐
             Possible values are:
                    Persists event logs and entries to the local file system.
                    The  directory  in which to persist the event logs, event
                    sources and entries can  be  specified  as  part  of  the
                    If  the  path  is  not  explicitly  set,  it  defaults to
                    "/var/lib/mono/eventlog" on unix  and  "%APPDATA%no\vent‐
                    log" on Windows.
                    Uses  the  native win32 API to write events and registers
                    event logs and event sources in the registry.    This  is
                    only available on Windows.
                    On  Unix,  the  directory permission for individual event
                    log and event source directories is set to 777  (with  +t
                    bit)  allowing  everyone  to  read  and  write  event log
                    entries while only allowing entries to be deleted by  the
                    user(s) that created them.
                    Silently discards any events.
             The  default  is  "null" on Unix (and versions of Windows before
             NT), and "win32" on Windows NT (and higher).
             If set, contains a colon-separated list of text encodings to try
             when  turning externally-generated text (e.g. command-line argu‐
             ments or filenames) into Unicode.  The encoding names come  from
             the   list   provided   by   iconv,   and   the   special   case
             "default_locale" which refers to the  current  locale's  default
             When  reading  externally-generated  text strings UTF-8 is tried
             first, and then this list is tried in order with the first  suc‐
             cessful  conversion  ending  the  search.  When writing external
             text (e.g. new filenames or  arguments  to  new  processes)  the
             first  item  in  this  list is used, or UTF-8 if the environment
             variable is not set.
             The problem with using MONO_EXTERNAL_ENCODINGS to  process  your
             files  is that it results in a problem: although its possible to
             get the right file name it is not necessarily possible  to  open
             the  file.   In  general  if you have problems with encodings in
             your filenames you should use the "convmv" program.
             Provides a prefix the runtime uses to look for  Global  Assembly
             Caches.   Directories are separated by the platform path separa‐
             tor (colons on unix). MONO_GAC_PREFIX should point  to  the  top
             directory of a prefixed install. Or to the directory provided in
             the    gacutil    /gacdir    command.    Example:    /home/user‐
             Enables  some filename rewriting support to assist badly-written
             applications that hard-code Windows paths.  Set to a colon-sepa‐
             rated  list  of  "drive" to strip drive letters, or "case" to do
             case-insensitive file matching in every  directory  in  a  path.
             "all"  enables  all  rewriting methods.  (Backslashes are always
             mapped to slashes if this variable is set to a valid option.)
             For example, this would work from the shell:
                  export MONO_IOMAP
             If you are using mod_mono to host your web applications, you can
             use the MonoSetEnv directive, like this:
                  MonoSetEnv MONO_IOMAP=all

             If  set  to  any value, System.IO.FileSystemWatcher will use the
             default managed implementation (slow). If unset, mono  will  try
             to  use  FAM under Unix systems and native API calls on Windows,
             falling back to the managed implementation on error.
             If set causes the mono process to be bound to a  single  proces‐
             sor.  This  may  be useful when debugging or working around race
             Provides a search path to the runtime where to look for  library
             files.    This  is a tool convenient for debugging applications,
             but should not be used by deployed applications as it breaks the
             assembly loader in subtle ways.
             Directories are separated by the platform path separator (colons
             on unix). Example: /home/username/lib:/usr/local/mono/lib
             Alternative solutions to MONO_PATH include: installing libraries
             into  the  Global  Assembly Cache (see gacutil(1)) or having the
             dependent libraries side-by-side with the main executable.
             For a complete description of recommended practices for applica‐
             tion   deployment,  see  the‐
             lines:Application_Deployment page.
             Experimental RTC support in the  statistical  profiler:  if  the
             user  has the permission, more accurate statistics are gathered.
             The MONO_RTC value must be restricted  to  what  the  Linux  rtc
             allows:  power  of two from 64 to 8192 Hz. To enable higher fre‐
             quencies like 4096 Hz, run as root:
                  echo 4096 > /proc/sys/dev/rtc/max-user-freq

             For example:
                  MONO_RTC=4096 mono --profiler=default:stat program.exe

             Disable inlining of thread local accesses. Try setting  this  if
             you get a segfault early on in the execution of mono.
             If  set  its  the  directory  where  the ".wapi" handle state is
             stored.  This is the directory where the Windows  I/O  Emulation
             layer  stores  its  shared  state  data (files, events, mutexes,
             pipes).  By default Mono will store the ".wapi" directory in the
             users's home directory.
             Uses  the string value of this variable as a replacement for the
             host name when creating file names  in  the  ".wapi"  directory.
             This  helps  if  the  host  name of your machine is likely to be
             changed when a mono application is running  or  if  you  have  a
             .wapi directory shared among several different computers.
             Mono  typically  uses  the hostname to create the files that are
             used to share state across multiple  Mono  processes.   This  is
             done  to  support home directories that might be shared over the
             If set, extra checks are made during IO operations.   Currently,
             this includes only advisory locks around file writes.
             If  set, disables the shared memory files used for cross-process
             handles: process have only private  handles.   This  means  that
             process and thread handles are not available to other processes,
             and named mutexes, named events and  named  semaphores  are  not
             visible between processes.
             This  is  can  also be enabled by default by passing the "--dis‐
             able-shared-handles" option to configure.
             The name of the theme to be used by  Windows.Forms.    Available
             themes today include "clearlooks", "nice" and "win32".
             The default is "win32".
             The  time,  in seconds, that the SSL/TLS session cache will keep
             it's entry to avoid a new negotiation between the client  and  a
             server.  Negotiation  are  very CPU intensive so an application-
             specific custom value may prove useful for small  embedded  sys‐
             The default is 180 seconds.
             The  maximum number of threads in the general threadpool will be
             20 + (MONO_THREADS_PER_CPU * number of CPUs). The default  value
             for this variable is 5.
             Controls the threshold for the XmlSerializer to produce a custom
             serializer for a given class instead of  using  the  Reflection-
             based  interpreter.  The possible values are `no' to disable the
             use of a custom serializer or a  number  to  indicate  when  the
             XmlSerializer  should  start serializing.   The default value is
             50, which means that the a custom serializer will be produced on
             the 50th use.
             Set  this value to 1 to prevent the serializer from removing the
             temporary files that are created for fast  serialization;   This
             might be useful when debugging.


             If set to any value, temporary source files generated by ASP.NET
             support classes will not be removed. They will be  kept  in  the
             user's temporary directory.
             The  logging  level,  possible  values  are `error', `critical',
             `warning', `message', `info' and  `debug'.   See  the  DEBUGGING
             section for more details.
             Controls  the domain of the Mono runtime that logging will apply
             to.  If set, the log mask is changed to the set value.  Possible
             values  are  "asm"  (assembly  loader),  "type",  "dll"  (native
             library loader), "gc" (garbage collector),  "cfg"  (config  file
             loader),  "aot"  (precompiler)  and "all".  The default value is
             "all". Changing the mask value allows you to display  only  mes‐
             sages  for  a  certain  component. You can use multiple masks by
             comma separating them. For example to see config  file  messages
             and assembly loader messages set you mask to "asm,cfg".
             Used  for  runtime  tracing  of  method calls. The format of the
             comma separated trace options is:
                  [-]M:method name
                  [-]T:class name
                  disabled       Trace output off upon start.
             You can toggle trace output on/off sending a SIGUSR2  signal  to
             the program.
             If  set,  enables  the  System.Diagnostics.DefaultTraceListener,
             which will print the output of the System.Diagnostics Trace  and
             Debug  classes.  It can be set to a filename, and to Console.Out
             or Console.Error to display output to standard output  or  stan‐
             dard  error,  respectively.  If  it's set to Console.Out or Con‐
             sole.Error you can append an optional prefix that will  be  used
             when  writing  messages  like this: Console.Error:MyProgramName.
             See  the  System.Diagnostics.DefaultTraceListener  documentation
             for more information.
             This  throws  an  exception  when a X11 error is encountered; by
             default a message is displayed but execution continues
             This is used in  the  System.Windows.Forms  implementation  when
             running with the X11 backend.  This is used to debug problems in
             Windows.Forms as it forces all  of  the  commands  send  to  X11
             server to be done synchronously.   The default mode of operation
             is asynchronous which makes it hard to isolate the root of  cer‐
             tain problems.
             This  environment  variable is completely unsupported, don't use
             it.  This controls for which  classes  to  enable  generic  code
             sharing  in  principle.   Permissible values are "all", "corlib"
             and "none".  The default is "none",  meaning  that  sharing  can
             only  happen for corlib classes.  Note that to enable generation
             of shared code the "gshared" compiler option has to  be  set  as


      If you want to use Valgrind, you will find the file `mono.supp' useful,
      it contains the suppressions for the GC which trigger  incorrect  warn‐
      ings.  Use it like this:
          valgrind --suppressions=mono.supp mono ...


      On  Unix assemblies are loaded from the installation lib directory.  If
      you set `prefix' to /usr, the assemblies will be located  in  /usr/lib.
      On Windows, the assemblies are loaded from the directory where mono and
      mint live.
             The directory for the  ahead-of-time  compiler  demand  creation
             assemblies are located.
      /etc/mono/config, ~/.mono/config
             Mono  runtime configuration file.  See the mono-config(5) manual
             page for more information.
      ~/.config/.mono/certs, /usr/share/.mono/certs
             Contains Mono certificate stores for users /  machine.  See  the
             certmgr(1) manual page for more information on managing certifi‐
             cate stores and the mozroots(1) page for information on  how  to
             import  the  Mozilla root certificates into the Mono certificate
             Files in this directory allow a user to customize the configura‐
             tion  for  a  given  system  assembly,  the  format  is  the one
             described in the mono-config(5) page.
      ~/.config/.mono/keypairs, /usr/share/.mono/keypairs
             Contains Mono cryptographic keypairs for users /  machine.  They
             can  be  accessed  by using a CspParameters object with DSACryp‐
             toServiceProvider and RSACryptoServiceProvider classes.
      ~/.config/.isolatedstorage,            ~/.local/share/.isolatedstorage,
             Contains Mono isolated storage for  non-roaming  users,  roaming
             users  and local machine. Isolated storage can be accessed using
             the classes from the System.IO.IsolatedStorage namespace.
             Configuration information for individual assemblies is loaded by
             the  runtime from side-by-side files with the .config files, see
             the for more information.
      Web.config, web.config
             ASP.NET applications are configured  through  these  files,  the
             configuration is done on a per-directory basis.  For more infor‐
             mation on this subject see the;
             fig_system.web page.


      Mailing  lists  are  listed  at  the;



      certmgr(1),  mcs(1),  monocov(1),  monodis(1),   mono-config(5),   moz‐
      roots(1), xsp(1).
      For more information on AOT:
      For ASP.NET-related documentation, see the xsp(1) manual page

                                                               Mono(Mono 1.0)