RUBY(1) UNIX RUBY(1)

# [NAME](#NAME)

**ruby** - Interpreted object-oriented scripting language

# [SYNOPSIS](#SYNOPSIS)

**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**] \[**--crash-report**=*template*] \[**--**] \[*program\_file*] \[*argument* ...]

# [DESCRIPTION](#DESCRIPTION)

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.

# [FEATURES](#FEATURES)

Ruby's features are as follows:

[**Interpretive**](#Interpretive)

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)

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**](#No)

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

[**Simple syntax**](#Simple)

Ruby has a simple syntax influenced slightly from Eiffel.

[**No user-level memory management**](#No~2)

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**](#Everything)

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**](#Class,)

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

[**Singleton methods**](#Singleton)

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**](#Mix-in)

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'.

[**Iterators**](#Iterators)

Ruby has iterators for loop abstraction.

[**Closures**](#Closures)

In Ruby, you can objectify the procedure.

[**Text processing and regular expressions**](#Text)

Ruby has a bunch of text processing features like in Perl.

[**M17N, character set independent**](#M17N,)

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.

[**Bignums**](#Bignums)

With built-in bignums, you can for example calculate factorial(400).

[**Reflection and domain-specific languages**](#Reflection)

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**](#Exception)

As in Java(tm).

[**Direct access to the OS**](#Direct)

Ruby can use most UNIX system calls, often used in system programming.

[**Dynamic loading**](#Dynamic)

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

[**Rich libraries**](#Rich)

In addition to the \`\`builtin libraries'' and \`\`standard libraries'' that are bundled with Ruby, a vast amount of third-party libraries (\`\`gems'') are available via the package management system called \`RubyGems', namely the [**gem**(1)](/man/os/ruby-4.0/gem.1) command. Visit RubyGems.org (**https://rubygems.org/**) to find the gems you need, and explore GitHub (**https://github.com/**) to see how they are being developed and used.

# [OPTIONS](#OPTIONS)

The Ruby interpreter accepts the following command-line options (switches). They are quite similar to those of [**perl**(1)](/man/os/ruby-4.0/perl.1).

[**--copyright**](#copyright)

Prints the copyright notice, and quits immediately without running any script.

**--version**

Prints the version of the Ruby interpreter, and quits immediately without running any script.

**-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*](#C)

[**-X** *directory*](#X)

Causes Ruby to switch to the directory.

[**-E** *external*\[:*internal*\]](#E)

[**--encoding** *external*\[:*internal*\]](#encoding)

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.

[**--external-encoding**=*encoding*](#external_encoding)

[**--internal-encoding**=*encoding*](#internal_encoding)

Specify the default external or internal character encoding

[**-F** *pattern*](#F)

Specifies input field separator ("$;").

[**-I** *directory*](#I)

Used to tell Ruby where to load the library scripts. Directory path will be added to the load-path variable ("$:").

[**-K** *kcode*](#K)

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**](#e)

EUC-JP

[**s**](#s)

Windows-31J (CP932)

[**u**](#u)

UTF-8

[**n**](#n)

ASCII-8BIT (BINARY)

[**-S**](#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 $*

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 [**csh**(1)](/man/os/ruby-4.0/csh.1).

[**-T**\[*level=1*\]](#T)

Turns on taint checks at the specified level (default 1).

[**-U**](#U)

Sets the default value for internal encodings ("Encoding.default\_internal") to UTF-8.

[**-W**\[*level=2*\]](#W)

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. **-W** 2 is the same as **-w**

[**-a**](#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.

[**--backtrace-limit**=*num*](#backtrace_limit)

Limits the maximum length of backtraces to *num* lines (default -1, meaning no limit).

[**-c**](#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.

[**-d**](#d)

[**--debug**](#debug)

Turns on debug mode. "$DEBUG" and "$VERBOSE" 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 name.

[**-h**](#h)

**--help**

Prints a summary of the options.

[**-i** *extension*](#i)

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  
matz  
% ruby -p -i.bak -e '$\_.upcase!' /tmp/junk  
% cat /tmp/junk  
MATZ  
% cat /tmp/junk.bak  
matz

[**-l**](#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 chomp!.

**-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  
...  
end

[**-p**](#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 '$\_.tr! "a-z", "A-Z"'  
MATZ

[**-r** *library*](#r)

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

[**-v**](#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**](#w)

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

[**-x**\[*directory*\]](#x)

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.

[**-y**](#y)

**--yydebug**

This option is not guaranteed to be compatible.

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.

[**--disable-FEATURE**](#disable-)

[**--enable-FEATURE**](#enable-)

Disables (or enables) the specified *FEATURE*.

[**--disable-gems**](#disable_gems)

[**--enable-gems**](#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 otherwise.

[**--disable-rubyopt**](#disable_rubyopt)

[**--enable-rubyopt**](#enable_rubyopt)

Ignores (or considers) the *RUBYOPT* environment variable. By default, Ruby considers the variable.

[**--disable-all**](#disable_all)

[**--enable-all**](#enable_all)

Disables (or enables) all features.

[**--dump**=*target*](#dump)

Dump some information.

Prints the specified target. *target* can be one of:

[**version**](#version)

Print version description (same as **--version).**

[**usage**](#usage)

Print a brief usage message (same as **-h).**

[**help**](#help)

Show long help message (same as **--help).**

[**syntax**](#syntax)

Check syntax (same as **-c** **--yydebug).**

Or one of the following, which are intended for debugging the interpreter:

[**yydebug**](#yydebug)

Enable compiler debug mode (same as **--yydebug).**

[**parsetree**](#parsetree)

Print a textual representation of the Ruby AST for the program.

[**insns**](#insns)

Print a list of disassembled bytecode instructions.

[**-optimize**](#optimize)

Disable various optimizations to print a list disassembled bytecode instructions.

**+error-tolerant**

Enable error-tolerant parsing, when yydebug or parsetree.

**+comment**

Annotate a textual representation of the Ruby AST for the program with the associated Ruby source code.

[**--verbose**](#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 script arguments (script file or **-e** options) are present, Ruby quits immediately.

[**--crash-report**=*template*](#crash_report)

Sets the template of path name to save crash report. See *RUBY\_CRASH\_REPORT* environment variable for details.

# [ENVIRONMENT](#ENVIRONMENT)

[**RUBYLIB**](#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 searched.

e.g.:

```
  RUBYLIB="$HOME/lib/ruby:$HOME/lib/rubyext"
```

[**RUBYOPT**](#RUBYOPT)

Additional Ruby options.

e.g.

```
  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**](#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**](#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 *COMSPEC.*

[**RUBY\_FREE\_AT\_EXIT**](#RUBY_FREE_AT_EXIT)

If set, Ruby tries to free all dynamically allocated memories. Introduced in Ruby 3.3, default: unset.

[**RUBY\_BOX**](#RUBY_BOX)

If set to 1, Ruby Box is enabled and users will be able to execute Ruby::Box.new. Ruby Box is an experimental feature introduced in Ruby 4.0.

[**RUBY\_IO\_BUFFER\_DEFAULT\_SIZE**](#RUBY_IO_BUFFER_DEFAULT_SIZE)

The custom default buffer size of IO::Buffer.

[**RUBY\_MAX\_CPU**](#RUBY_MAX_CPU)

The maximum number of native threads used by M:N Threads scheduler Introduced in Ruby 3.3, default: 8.

[**RUBY\_MN\_THREADS**](#RUBY_MN_THREADS)

If set to 1, M:N Thread scheduler is enabled on the main Ractor. Introduced in Ruby 3.3, default: unset.

[**RUBY\_PAGER**](#RUBY_PAGER)

The pager command that will be used for **--help** option. Introduced in Ruby 3.0, default: *PAGER* environment variable.

[**RUBY\_THREAD\_TIMESLICE**](#RUBY_THREAD_TIMESLICE)

Sets the default thread time slice (thread quantum) in milliseconds. Introduced in Ruby 3.4, default: 100ms.

[**PATH**](#PATH)

Ruby refers to the *PATH* environment variable on calling Kernel#system.

And Ruby depends on some RubyGems related environment variables unless RubyGems is disabled. See the help of [**gem**(1)](/man/os/ruby-4.0/gem.1) as below.

% gem help

# [GC ENVIRONMENT](#GC_ENVIRONMENT)

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)](/man/os/ruby-4.0/malloc.3), [**calloc**(3)](/man/os/ruby-4.0/calloc.3), and [**realloc**(3)](/man/os/ruby-4.0/realloc.3)) In this documentation, 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 following environment variables:

[**RUBY\_GC\_HEAP\_*n*.IR \_INIT\_SLOTS**](#RUBY_GC_HEAP_)

Initial allocation of slots in a specific heap. The available heaps can be found in the keys of GC.stat\_heap. *n* is a decimal number between 0 and 4. Introduced in Ruby 3.3.

[**RUBY\_GC\_HEAP\_FREE\_SLOTS**](#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**](#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**](#RUBY_GC_HEAP_GROWTH_MAX_SLOTS)

Allocation rate is limited to this number of slots, preventing excessive allocation due to RUBY\_GC\_HEAP\_GROWTH\_FACTOR. Introduced in Ruby 2.1, default: 0 (no limit)

[**RUBY\_GC\_HEAP\_OLDOBJECT\_LIMIT\_FACTOR**](#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\_HEAP\_REMEMBERED\_WB\_UNPROTECTED\_OBJECTS\_LIMIT\_RATIO**](#RUBY_GC_HEAP_REMEMBERED_WB_UNPROTECTED_OBJECTS_LIMIT_RATIO)

Used to calculate the remembered\_wb\_unprotected\_objects\_limit using a ratio of old\_objects. Introduced in Ruby 3.3, default: 0.1, minimum: 0.0

[**RUBY\_GC\_MALLOC\_LIMIT**](#RUBY_GC_MALLOC_LIMIT)

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

[**RUBY\_GC\_MALLOC\_LIMIT\_MAX**](#RUBY_GC_MALLOC_LIMIT_MAX)

The maximum limit of young generation allocation from malloc before GC starts. Prevents excessive malloc growth due to RUBY\_GC\_MALLOC\_LIMIT\_GROWTH\_FACTOR. Introduced in Ruby 2.1, default: 32MB.

[**RUBY\_GC\_MALLOC\_LIMIT\_GROWTH\_FACTOR**](#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 growth)

[**RUBY\_GC\_HEAP\_FREE\_SLOTS\_MIN\_RATIO**](#RUBY_GC_HEAP_FREE_SLOTS_MIN_RATIO)

Allocate additional pages when the number of free slots is lower than the value (total\_slots * (this ratio)). Introduced in Ruby 2.4, default: 0.2, minimum: 0.0, maximum: 1.0

[**RUBY\_GC\_HEAP\_FREE\_SLOTS\_MAX\_RATIO**](#RUBY_GC_HEAP_FREE_SLOTS_MAX_RATIO)

Allow to free pages when the number of free slots is greater than the value (total\_slots * (this ratio)). Introduced in Ruby 2.4, default: 0.4, minimum: RUBY\_GC\_HEAP\_FREE\_SLOTS\_MIN\_RATIO, maximum: 1.0

[**RUBY\_GC\_HEAP\_FREE\_SLOTS\_GOAL\_RATIO**](#RUBY_GC_HEAP_FREE_SLOTS_GOAL_RATIO)

Allocate slots to satisfy this formula: free\_slots = total\_slots * goal\_ratio In other words, prepare (total\_slots * goal\_ratio) free slots. if this value is 0.0, then use RUBY\_GC\_HEAP\_GROWTH\_FACTOR directly. Introduced in Ruby 2.4, default: 0.65, minimum: RUBY\_GC\_HEAP\_FREE\_SLOTS\_MIN\_RATIO, maximum: RUBY\_GC\_HEAP\_FREE\_SLOTS\_MAX\_RATIO

[**RUBY\_GC\_OLDMALLOC\_LIMIT**](#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**](#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 RUBY\_GC\_OLDMALLOC\_LIMIT\_GROWTH\_FACTOR. Introduced in Ruby 2.1, default: 128MB

[**RUBY\_GC\_OLDMALLOC\_LIMIT\_GROWTH\_FACTOR**](#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 growth)

[**RUBY\_SHARED\_FIBER\_POOL\_FREE\_STACKS**](#RUBY_SHARED_FIBER_POOL_FREE_STACKS)

Frees stacks of pooled fibers, if set to 1. Do not free the stacks if set to 0. Introduced in Ruby 2.7, default: 1 (no growth)

# [STACK SIZE ENVIRONMENT](#STACK_SIZE_ENVIRONMENT)

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**](#RUBY_THREAD_VM_STACK_SIZE)

VM stack size used at thread creation. default: 524288 (32-bit CPU) or 1048576 (64-bit)

[**RUBY\_THREAD\_MACHINE\_STACK\_SIZE**](#RUBY_THREAD_MACHINE_STACK_SIZE)

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

[**RUBY\_FIBER\_VM\_STACK\_SIZE**](#RUBY_FIBER_VM_STACK_SIZE)

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

[**RUBY\_FIBER\_MACHINE\_STACK\_SIZE**](#RUBY_FIBER_MACHINE_STACK_SIZE)

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

# [CRASH REPORT ENVIRONMENT](#CRASH_REPORT_ENVIRONMENT)

[**RUBY\_CRASH\_REPORT**](#RUBY_CRASH_REPORT)

The template of path name to save crash report. default: none

## [Naming crash report files](#Naming_crash_report_files)

The template can contain **%** specifiers which are substituted by the following values when a crash report file is created:

**%%**

A single **%** character.

**%e**

Basename of executable.

**%E**

Pathname of executable, with slashes (**/**) replaced by exclamation marks (**!**).

**%f**

Basename of the program name, "$0".

**%F**

Pathname of the program name, "$0", with slashes (**/**) replaced by exclamation marks (**!**).

**%p**

PID of dumped process.

**%t**

Time of dump, expressed as seconds since the Epoch, 1970-01-01 00:00:00 +0000 (UTC).

**%NNN**

A character code in octal.

A single **%** at the end of the template is dropped from the core filename, as is the combination of a **%** followed by any character other than those listed above. All other characters in the template become a literal part of the core filename. The template may include '/' characters, which are interpreted as delimiters for directory names.

## [Piping crash reports to a program](#Piping_crash_reports_to_a_program)

If the first character of this file is a pipe symbol (**|**), then the remainder of the line is interpreted as the command-line for a program (or script) that is to be executed.

The pipe template is split on spaces into an argument list before the template parameters are expanded.

# [MISC ENVIRONMENT](#MISC_ENVIRONMENT)

[**RUBY\_TCP\_NO\_FAST\_FALLBACK**](#RUBY_TCP_NO_FAST_FALLBACK)

If set to 1, disables the fast fallback feature by default in TCPSocket.new and Socket.tcp. When set to 0 or left unset, the fast fallback feature is enabled. Introduced in Ruby 3.4, default: unset.

# [SEE ALSO](#SEE_ALSO)

[**https://www.ruby-lang.org/**](https://www.ruby-lang.org/)

The official web site.

[**https://www.ruby-toolbox.com/**](https://www.ruby-toolbox.com/)

Comprehensive catalog of Ruby libraries.

# [REPORTING BUGS](#REPORTING_BUGS)

- Security vulnerabilities should be reported via an email to Mt security@ruby-lang.org. Reported problems will be published after being fixed.
- Other bugs and feature requests can be reported via the Ruby Issue Tracking System (**https://bugs.ruby-lang.org/**). Do not report security vulnerabilities via this system because it publishes the vulnerabilities immediately.

# [AUTHORS](#AUTHORS)

Ruby is designed and implemented by Yukihiro Matsumoto <matz@netlab.jp>.

See <**https://github.com/ruby/ruby/graphs/contributors**> for contributors to Ruby.

Ruby Programmer's Reference Guide April 14, 2018

---

Document: ruby(1) from ruby-4.0 4.0.9-r1 (Chainguard OS)
Source: https://github.com/ruby/ruby