ruby --- Interpreted object-oriented scripting language


     ruby [--copyright] [--version] [-SUacdlnpswvy] [-0[octal]] [-C directory]
      [-E external[:internal]] [-F[pattern]] [-I directory] [-K[c]]
      [-T[level]] [-W[level]] [-e command] [-i[extension]] [-r library]
      [-x[directory]] [--{enable|disable}-FEATURE] [--dump=target]
      [--verbose] [--] [program_file] [argument ...]


     Ruby is an interpreted scripting language for quick and easy object-
     oriented programming.  It has many features to process text files and to
     do system management tasks (like in Perl).  It is simple, straight-
     forward, and extensible.

     If you want a language for easy object-oriented programming, or you don't
     like the Perl ugliness, or you do like the concept of LISP, but don't
     like too many parentheses, Ruby might be your language of choice.


     Ruby's features are as follows:

         Ruby is an interpreted language, so you don't have to recompile
         programs written in Ruby to execute them.

     Variables have no type (dynamic typing)
         Variables in Ruby can contain data of any type.  You don't have
         to worry about variable typing.  Consequently, it has a weaker
         compile time check.

     No declaration needed
         You can use variables in your Ruby programs without any
         declarations.  Variable names denote their scope - global, class,
         instance, or local.

     Simple syntax
         Ruby has a simple syntax influenced slightly from Eiffel.

     No user-level memory management
         Ruby has automatic memory management.  Objects no longer
         referenced from anywhere are automatically collected by the
         garbage collector built into the interpreter.

     Everything is an object
         Ruby is a purely object-oriented language, and was so since its
         creation.  Even such basic data as integers are seen as objects.

     Class, inheritance, and methods
         Being an object-oriented language, Ruby naturally has basic
         features like classes, inheritance, and methods.

     Singleton methods
         Ruby has the ability to define methods for certain objects.  For
         example, you can define a press-button action for certain widget
         by defining a singleton method for the button.  Or, you can make
         up your own prototype based object system using singleton
         methods, if you want to.

     Mix-in by modules
         Ruby intentionally does not have the multiple inheritance as it
         is a source of confusion.  Instead, Ruby has the ability to share
         implementations across the inheritance tree.  This is often
         called a 'Mix-in'.

         Ruby has iterators for loop abstraction.

         In Ruby, you can objectify the procedure.

     Text processing and regular expressions
         Ruby has a bunch of text processing features like in Perl.

     M17N, character set independent
         Ruby supports multilingualized programming. Easy to process texts
         written in many different natural languages and encoded in many
         different character encodings, without dependence on Unicode.

         With built-in bignums, you can for example calculate

     Reflection and domain specific languages
         Class is also an instance of the Class class. Definition of
         classes and methods is an expression just as 1+1 is. So your
         programs can even write and modify programs.  Thus you can write
         your application in your own programming language on top of Ruby.

     Exception handling
         As in Java(tm).

     Direct access to the OS
         Ruby can use most UNIX system calls, often used in system

     Dynamic loading
         On most UNIX systems, you can load object files into the Ruby
         interpreter on-the-fly.

     Rich libraries
         Libraries called "builtin libraries" and "standard libraries" are
         bundled with Ruby.  And you can obtain more libraries via the
         package management system called `RubyGems'.

         Moreover there are thousands of Ruby projects on GitHub


     Ruby interpreter accepts following command-line options (switches).  They
     are quite similar to those of perl(1).

     --copyright    Prints the copyright notice.

     --version      Prints the version of Ruby interpreter.

     -0[octal]      (The digit "zero".)  Specifies the input record separator
                ($/) as an octal number. If no digit is given, the null
                character is taken as the separator.  Other switches may
                follow the digits.  -00 turns Ruby into paragraph mode.
                -0777 makes Ruby read whole file at once as a single
                string since there is no legal character with that value.

     -C directory
     -X directory   Causes Ruby to switch to the directory.

     -E external[:internal]
     --encoding external[:internal]
                Specifies the default value(s) for external encodings and
                internal encoding. Values should be separated with colon

                You can omit the one for internal encodings, then the
                value (Encoding.default_internal) will be nil.

                Specify the default external or internal character

     -F pattern     Specifies input field separator ($;).

     -I directory   Used to tell Ruby where to load the library scripts.
                Directory path will be added to the load-path variable

     -K kcode       Specifies KANJI (Japanese) encoding. The default value for
                script encodings (__ENCODING__) and external encodings
                (Encoding.default_external) will be the specified one.
                kcode can be one of

                      e       EUC-JP

                      s       Windows-31J (CP932)

                      u       UTF-8

                      n       ASCII-8BIT (BINARY)

     -S             Makes Ruby use the PATH environment variable to search for
                script, unless its name begins with a slash.  This is used
                to emulate #! on machines that don't support it, in the
                following manner:

                      #! /usr/local/bin/ruby
                      # This line makes the next one a comment in Ruby \
                        exec /usr/local/bin/ruby -S $0 $*

     -T[level=1]    Turns on taint checks at the specified level (default 1).

     -U             Sets the default value for internal encodings
                (Encoding.default_internal) to UTF-8.

     -W[level=2]    Turns on verbose mode at the specified level without
                printing the version message at the beginning. The level
                can be;

                      0       Verbose mode is "silence". It sets the
                              $VERBOSE to nil.

                      1       Verbose mode is "medium". It sets the
                              $VERBOSE to false.

                      2 (default) Verbose mode is "verbose". It sets the
                              $VERBOSE to true.  -W2 is same as -w

     -a             Turns on auto-split mode when used with -n or -p.  In
                auto-split mode, Ruby executes
                      $F = $_.split
                at beginning of each loop.

     -c             Causes Ruby to check the syntax of the script and exit
                without executing. If there are no syntax errors, Ruby
                will print "Syntax OK" to the standard output.

     --debug        Turns on debug mode.  $DEBUG will be set to true.

     -e command     Specifies script from command-line while telling Ruby not
                to search the rest of the arguments for a script file

     --help         Prints a summary of the options.

     -i extension   Specifies in-place-edit mode.  The extension, if
                specified, is added to old file name to make a backup
                copy.  For example:

                      % echo matz > /tmp/junk
                      % cat /tmp/junk
                      % ruby -p -i.bak -e '$_.upcase!' /tmp/junk
                      % cat /tmp/junk
                      % cat /tmp/junk.bak

     -l             (The lowercase letter "ell".)  Enables automatic line-
                ending processing, which means to firstly set $\ to the
                value of $/, and secondly chops every line read using

     -n             Causes Ruby to assume the following loop around your
                script, which makes it iterate over file name arguments
                somewhat like sed -n or awk.

                      while gets

     -p             Acts mostly same as -n switch, but print the value of
                variable $_ at the each end of the loop.  For example:

                      % echo matz | ruby -p -e '$! "a-z", "A-Z"'

     -r library     Causes Ruby to load the library using require.  It is
                useful when using -n or -p.

     -s             Enables some switch parsing for switches after script name
                but before any file name arguments (or before a --).  Any
                switches found there are removed from ARGV and set the
                corresponding variable in the script.  For example:

                      #! /usr/local/bin/ruby -s
                      # prints "true" if invoked with `-xyz' switch.
                      print "true\n" if $xyz

                On some systems $0 does not always contain the full
                pathname, so you need the -S switch to tell Ruby to search
                for the script if necessary (to handle embedded spaces and
                such).  A better construct than $* would be ${1+"$@"}, but
                it does not work if the script is being interpreted by

     -v             Enables verbose mode.  Ruby will print its version at the
                beginning and set the variable $VERBOSE to true.  Some
                methods print extra messages if this variable is true.  If
                this switch is given, and no other switches are present,
                Ruby quits after printing its version.

     -w             Enables verbose mode without printing version message at
                the beginning.  It sets the $VERBOSE variable to true.

     -x[directory]  Tells Ruby that the script is embedded in a message.
                Leading garbage will be discarded until the first line
                that starts with "#!" and contains the string, "ruby".
                Any meaningful switches on that line will be applied.  The
                end of the script must be specified with either EOF, ^D
                (control-D), ^Z (control-Z), or the reserved word __END__.
                If the directory name is specified, Ruby will switch to
                that directory before executing script.

     --yydebug      DO NOT USE.

                Turns on compiler debug mode.  Ruby will print a bunch of
                internal state messages during compilation.  Only specify
                this switch you are going to debug the Ruby interpreter.

                Disables (or enables) the specified FEATURE.
                --enable-gems      Disables (or enables) RubyGems
                                   libraries.  By default, Ruby will load
                                   the latest version of each installed
                                   gem. The Gem constant is true if
                                   RubyGems is enabled, false if

                --enable-rubyopt   Ignores (or considers) the RUBYOPT
                                   environment variable. By default, Ruby
                                   considers the variable.

                --enable-all       Disables (or enables) all features.

     --dump=target  Dump some informations.

                Prints the specified target.  target can be one of;

                      version version description same as --version

                      usage   brief usage message same as -h

                      help    Show long help message same as --help

                      syntax  check of syntax same as -c --yydebug

                      yydebug compiler debug mode, same as --yydebug

                              Only specify this switch if you are going to
                              debug the Ruby interpreter.


                      parsetree_with_comment AST nodes tree

                              Only specify this switch if you are going to
                              debug the Ruby interpreter.

                      insns   disassembled instructions

                              Only specify this switch if you are going to
                              debug the Ruby interpreter.

     --verbose      Enables verbose mode without printing version message at
                the beginning.  It sets the $VERBOSE variable to true.  If
                this switch is given, and no other switches are present,
                Ruby quits after printing its version.


     RUBYLIB    A colon-separated list of directories that are added to Ruby's
            library load path ($:). Directories from this environment
            variable are searched before the standard load path is


     RUBYOPT    Additional Ruby options.

                  RUBYOPT="-w -Ke"

            Note that RUBYOPT can contain only -d, -E, -I, -K, -r, -T, -U,
            -v, -w, -W, --debug, --disable-FEATURE and --enable-FEATURE.

     RUBYPATH   A colon-separated list of directories that Ruby searches for
            Ruby programs when the -S flag is specified.  This variable
            precedes the PATH environment variable.

     RUBYSHELL  The path to the system shell command.  This environment
            variable is enabled for only mswin32, mingw32, and OS/2
            platforms.  If this variable is not defined, Ruby refers to

     PATH       Ruby refers to the PATH environment variable on calling

     And Ruby depends on some RubyGems related environment variables unless
     RubyGems is disabled.  See the help of gem(1) as below.

       % gem help


     The Ruby garbage collector (GC) tracks objects in fixed-sized slots, but
     each object may have auxiliary memory allocations handled by the malloc
     family of C standard library calls ( malloc(3), calloc(3), and
     realloc(3)).  In this documentatation, the "heap" refers to the Ruby
     object heap of fixed-sized slots, while "malloc" refers to auxiliary
     allocations commonly referred to as the "process heap".  Thus there are
     at least two possible ways to trigger GC:

       1       Reaching the object limit.

       2       Reaching the malloc limit.

     In Ruby 2.1, the generational GC was introduced and the limits are
     divided into young and old generations, providing two additional ways to
     trigger a GC:

       3       Reaching the old object limit.

       4       Reaching the old malloc limit.

     There are currently 4 possible areas where the GC may be tuned by the the
     following 11 environment variables:
     RUBY_GC_HEAP_INIT_SLOTS                Initial allocation slots.
                                        Introduced in Ruby 2.1, default:

     RUBY_GC_HEAP_FREE_SLOTS                Prepare at least this amount of
                                        slots after GC.  Allocate this
                                        number slots if there are not
                                        enough slots.  Introduced in Ruby
                                        2.1, default: 4096

     RUBY_GC_HEAP_GROWTH_FACTOR             Increase allocation rate of heap
                                        slots by this factor.  Introduced
                                        in Ruby 2.1, default: 1.8,
                                        minimum: 1.0 (no growth)

     RUBY_GC_HEAP_GROWTH_MAX_SLOTS          Allocation rate is limited to this
                                        number of slots, preventing
                                        excessive allocation due to
                                        Introduced in Ruby 2.1, default: 0
                                        (no limit)

     RUBY_GC_HEAP_OLDOBJECT_LIMIT_FACTOR    Perform a full GC when the number
                                        of old objects is more than R * N,
                                        where R is this factor and N is
                                        the number of old objects after
                                        the last full GC.  Introduced in
                                        Ruby 2.1.1, default: 2.0

     RUBY_GC_MALLOC_LIMIT                   The initial limit of young
                                        generation allocation from the
                                        malloc-family.  GC will start when
                                        this limit is reached.  Default:

     RUBY_GC_MALLOC_LIMIT_MAX               The maximum limit of young
                                        generation allocation from malloc
                                        before GC starts.  Prevents
                                        excessive malloc growth due to
                                        Introduced in Ruby 2.1, default:

     RUBY_GC_MALLOC_LIMIT_GROWTH_FACTOR     Increases the limit of young
                                        generation malloc calls, reducing
                                        GC frequency but increasing malloc
                                        growth until
                                        RUBY_GC_MALLOC_LIMIT_MAX is
                                        reached.  Introduced in Ruby 2.1,
                                        default: 1.4, minimum: 1.0 (no

     RUBY_GC_OLDMALLOC_LIMIT                The initial limit of old
                                        generation allocation from malloc,
                                        a full GC will start when this
                                        limit is reached.  Introduced in
                                        Ruby 2.1, default: 16MB

     RUBY_GC_OLDMALLOC_LIMIT_MAX            The maximum limit of old
                                        generation allocation from malloc
                                        before a full GC starts.  Prevents
                                        excessive malloc growth due to
                                        Introduced in Ruby 2.1, default:

     RUBY_GC_OLDMALLOC_LIMIT_GROWTH_FACTOR  Increases the limit of old
                                        generation malloc allocation,
                                        reducing full GC frequency but
                                        increasing malloc growth until
                                        RUBY_GC_OLDMALLOC_LIMIT_MAX is
                                        reached.  Introduced in Ruby 2.1,
                                        default: 1.2, minimum: 1.0 (no


     Stack size environment variables are implementation-dependent and subject
     to change with different versions of Ruby.  The VM stack is used for
     pure-Ruby code and managed by the virtual machine.  Machine stack is used
     by the operating system and its usage is dependent on C extensions as
     well as C compiler options.  Using lower values for these may allow
     applications to keep more Fibers or Threads running; but increases the
     chance of SystemStackError exceptions and segmentation faults (SIGSEGV).
     These environment variables are available since Ruby 2.0.0.  All values
     are specified in bytes.

     RUBY_THREAD_VM_STACK_SIZE       VM stack size used at thread creation.
                                 default: 131072 (32-bit CPU) or 262144

     RUBY_THREAD_MACHINE_STACK_SIZE  Machine stack size used at thread
                                 creation.  default: 524288 or 1048575

     RUBY_FIBER_VM_STACK_SIZE        VM stack size used at fiber creation.
                                 default: 65536 or 131072

     RUBY_FIBER_MACHINE_STACK_SIZE   Machine stack size used at fiber
                                 creation.  default: 262144 or 524288

SEE ALSO    The official web site. Comprehensive catalog of Ruby libraries.


     Security vulnerabilities should be reported via an email to  Reported problems will be published after
     they've been fixed.

     And you can report other bugs and feature requests via the Ruby Issue
     Tracking System (  Do not report security
     vulnerabilities via the system because it publishes the vulnerabilities


     Ruby is designed and implemented by Yukihiro Matsumoto

     See for
     contributors to Ruby.


Personal Opportunity - Free software gives you access to billions of dollars of software at no cost. Use this software for your business, personal use or to develop a profitable skill. Access to source code provides access to a level of capabilities/information that companies protect though copyrights. Open source is a core component of the Internet and it is available to you. Leverage the billions of dollars in resources and capabilities to build a career, establish a business or change the world. The potential is endless for those who understand the opportunity.

Business Opportunity - Goldman Sachs, IBM and countless large corporations are leveraging open source to reduce costs, develop products and increase their bottom lines. Learn what these companies know about open source and how open source can give you the advantage.

Free Software

Free Software provides computer programs and capabilities at no cost but more importantly, it provides the freedom to run, edit, contribute to, and share the software. The importance of free software is a matter of access, not price. Software at no cost is a benefit but ownership rights to the software and source code is far more significant.

Free Office Software - The Libre Office suite provides top desktop productivity tools for free. This includes, a word processor, spreadsheet, presentation engine, drawing and flowcharting, database and math applications. Libre Office is available for Linux or Windows.

Free Books

The Free Books Library is a collection of thousands of the most popular public domain books in an online readable format. The collection includes great classical literature and more recent works where the U.S. copyright has expired. These books are yours to read and use without restrictions.

Source Code - Want to change a program or know how it works? Open Source provides the source code for its programs so that anyone can use, modify or learn how to write those programs themselves. Visit the GNU source code repositories to download the source.


Study at Harvard, Stanford or MIT - Open edX provides free online courses from Harvard, MIT, Columbia, UC Berkeley and other top Universities. Hundreds of courses for almost all major subjects and course levels. Open edx also offers some paid courses and selected certifications.

Linux Manual Pages - A man or manual page is a form of software documentation found on Linux/Unix operating systems. Topics covered include computer programs (including library and system calls), formal standards and conventions, and even abstract concepts.