In Files

  • irb.rb
  • irb/cmd/chws.rb
  • irb/cmd/fork.rb
  • irb/cmd/help.rb
  • irb/cmd/load.rb
  • irb/cmd/nop.rb
  • irb/cmd/pushws.rb
  • irb/cmd/subirb.rb
  • irb/color.rb
  • irb/completion.rb
  • irb/context.rb
  • irb/easter-egg.rb
  • irb/ext/change-ws.rb
  • irb/ext/history.rb
  • irb/ext/loader.rb
  • irb/ext/multi-irb.rb
  • irb/ext/save-history.rb
  • irb/ext/tracer.rb
  • irb/ext/use-loader.rb
  • irb/ext/workspaces.rb
  • irb/extend-command.rb
  • irb/frame.rb
  • irb/help.rb
  • irb/init.rb
  • irb/input-method.rb
  • irb/inspector.rb
  • irb/lc/error.rb
  • irb/lc/ja/encoding_aliases.rb
  • irb/lc/ja/error.rb
  • irb/locale.rb
  • irb/magic-file.rb
  • irb/notifier.rb
  • irb/output-method.rb
  • irb/src_encoding.rb
  • irb/version.rb
  • irb/workspace.rb
  • irb/ws-for-case-2.rb
  • irb/xmp.rb


IRB stands for “interactive Ruby” and is a tool to interactively execute Ruby expressions read from the standard input.

The irb command from your shell will start the interpreter.


Use of irb is easy if you know Ruby.

When executing irb, prompts are displayed as follows. Then, enter the Ruby expression. An input is executed when it is syntactically complete.

$ irb
irb(main):001:0> 1+2
#=> 3
irb(main):002:0> class Foo
irb(main):003:1>  def foo
irb(main):004:2>    print 1
irb(main):005:2>  end
irb(main):006:1> end
#=> nil

The singleline editor module or multiline editor module can be used with irb. Use of multiline editor is default if it’s installed.

Command line options

Usage:  irb.rb [options] [programfile] [arguments]
  -f                Suppress read of ~/.irbrc
  -d                Set $DEBUG to true (same as `ruby -d')
  -r load-module    Same as `ruby -r'
  -I path           Specify $LOAD_PATH directory
  -U                Same as `ruby -U`
  -E enc            Same as `ruby -E`
  -w                Same as `ruby -w`
  -W[level=2]       Same as `ruby -W`
  --inspect         Use `inspect' for output (default except for bc mode)
  --noinspect       Don't use inspect for output
  --multiline       Use multiline editor module
  --nomultiline     Don't use multiline editor module
  --singleline      Use singleline editor module
  --nosingleline    Don't use singleline editor module
  --colorize        Use colorization
  --nocolorize      Don't use colorization
  --prompt prompt-mode
  --prompt-mode prompt-mode
                    Switch prompt mode. Pre-defined prompt modes are
                    `default', `simple', `xmp' and `inf-ruby'
  --inf-ruby-mode   Use prompt appropriate for inf-ruby-mode on emacs.
                    Suppresses --multiline and --singleline.
  --simple-prompt   Simple prompt mode
  --noprompt        No prompt mode
  --tracer          Display trace for each execution of commands.
  --back-trace-limit n
                    Display backtrace top n and tail n. The default
                    value is 16.
  -v, --version     Print the version of irb


IRB reads from ~/.irbrc when it’s invoked.

If ~/.irbrc doesn’t exist, irb will try to read in the following order:

  • .irbrc

  • irb.rc

  • _irbrc

  • $irbrc

The following are alternatives to the command line options. To use them type as follows in an irb session:

IRB.conf[:IRB_RC] = nil
IRB.conf[:USE_LOADER] = false
IRB.conf[:USE_MULTILINE] = nil
IRB.conf[:USE_COLORIZE] = true
IRB.conf[:USE_TRACER] = false
IRB.conf[:IGNORE_SIGINT] = true
IRB.conf[:IGNORE_EOF] = false
IRB.conf[:PROMPT] = {...}

Auto indentation

To disable auto-indent mode in irb, add the following to your .irbrc:

IRB.conf[:AUTO_INDENT] = false


To enable autocompletion for irb, add the following to your .irbrc:

require 'irb/completion'


By default, irb will store the last 1000 commands you used in IRB.conf[:HISTORY_FILE] (~/.irb_history by default).

If you want to disable history, add the following to your .irbrc:

IRB.conf[:SAVE_HISTORY] = nil

See IRB::Context#save_history= for more information.

The history of results of commands evaluated is not stored by default, but can be turned on to be stored with this .irbrc setting:

IRB.conf[:EVAL_HISTORY] = <number>

See IRB::Context#eval_history= and History class. The history of command results is not permanently saved in any file.

Customizing the IRB Prompt

In order to customize the prompt, you can change the following Hash:


This example can be used in your .irbrc

IRB.conf[:PROMPT][:MY_PROMPT] = { # name of prompt mode
  :AUTO_INDENT => false,          # disables auto-indent mode
  :PROMPT_I =>  ">> ",            # simple prompt
  :PROMPT_S => nil,               # prompt for continuated strings
  :PROMPT_C => nil,               # prompt for continuated statement
  :RETURN => "    ==>%s\n"        # format to return value


Or, invoke irb with the above prompt mode by:

irb --prompt my-prompt

Constants PROMPT_I, PROMPT_S and PROMPT_C specify the format. In the prompt specification, some special strings are available:

%N    # command name which is running
%m    # to_s of main object (self)
%M    # inspect of main object (self)
%l    # type of string(", ', /, ]), `]' is inner %w[...]
%NNi  # indent level. NN is digits and means as same as printf("%NNd").
      # It can be omitted
%NNn  # line number.
%%    # %

For instance, the default prompt mode is defined as follows:

  :PROMPT_I => "%N(%m):%03n:%i> ",
  :PROMPT_N => "%N(%m):%03n:%i> ",
  :PROMPT_S => "%N(%m):%03n:%i%l ",
  :PROMPT_C => "%N(%m):%03n:%i* ",
  :RETURN => "%s\n" # used to printf

irb comes with a number of available modes:

# :NULL:
#   :PROMPT_I:
#   :PROMPT_N:
#   :PROMPT_S:
#   :PROMPT_C:
#   :RETURN: |
#     %s
#   :PROMPT_I: ! '%N(%m):%03n:%i> '
#   :PROMPT_N: ! '%N(%m):%03n:%i> '
#   :PROMPT_S: ! '%N(%m):%03n:%i%l '
#   :PROMPT_C: ! '%N(%m):%03n:%i* '
#   :RETURN: |
#     => %s
#   :PROMPT_I: ! '%N(%m):%03n:%i> '
#   :PROMPT_N: ! '%N(%m):%03n:%i> '
#   :PROMPT_S: ! '%N(%m):%03n:%i%l '
#   :PROMPT_C: ! '%N(%m):%03n:%i* '
#   :RETURN: |
#     %s
#   :PROMPT_I: ! '>> '
#   :PROMPT_N: ! '>> '
#   :PROMPT_S:
#   :PROMPT_C: ! '?> '
#   :RETURN: |
#     => %s
#   :PROMPT_I: ! '%N(%m):%03n:%i> '
#   :PROMPT_N:
#   :PROMPT_S:
#   :PROMPT_C:
#   :RETURN: |
#     %s
#   :AUTO_INDENT: true
# :XMP:
#   :PROMPT_I:
#   :PROMPT_N:
#   :PROMPT_S:
#   :PROMPT_C:
#   :RETURN: |2
#         ==>%s


Because irb evaluates input immediately after it is syntactically complete, the results may be slightly different than directly using Ruby.

IRB Sessions

IRB has a special feature, that allows you to manage many sessions at once.

You can create new sessions with Irb.irb, and get a list of current sessions with the jobs command in the prompt.


JobManager provides commands to handle the current sessions:

jobs    # List of current sessions
fg      # Switches to the session of the given number
kill    # Kills the session with the given number

The exit command, or ::irb_exit, will quit the current session and call any exit hooks with ::irb_at_exit.

A few commands for loading files within the session are also available:


Loads a given file in the current session and displays the source lines, see IRB::IrbLoader#source_file


Loads the given file similarly to Kernel#load, see IRB::IrbLoader#irb_load


Loads the given file similarly to Kernel#require


The command line options, or ::conf, specify the default behavior of Irb.irb.

On the other hand, each conf in IRB is used to individually configure ::irb.

If a proc is set for ::conf, its will be invoked after execution of that proc with the context of the current session as its argument. Each session can be configured using this mechanism.

Session variables

There are a few variables in every Irb session that can come in handy:


The value command executed, as a local variable


The history of evaluated commands. Available only if IRB.conf[:EVAL_HISTORY] is not nil (which is the default). See also IRB::Context#eval_history= and IRB::History.


Returns the evaluation value at the given line number, line_no. If line_no is a negative, the return value line_no many lines before the most recent return value.

Example using IRB Sessions

# invoke a new session
irb(main):001:0> irb
# list open sessions
irb.1(main):001:0> jobs
  #0->irb on main (#<Thread:0x400fb7e4> : stop)
  #1->irb#1 on main (#<Thread:0x40125d64> : running)

# change the active session
irb.1(main):002:0> fg 0
# define class Foo in top-level session
irb(main):002:0> class Foo;end
# invoke a new session with the context of Foo
irb(main):003:0> irb Foo
# define Foo#foo
irb.2(Foo):001:0> def foo
irb.2(Foo):002:1>   print 1
irb.2(Foo):003:1> end

# change the active session
irb.2(Foo):004:0> fg 0
# list open sessions
irb(main):004:0> jobs
  #0->irb on main (#<Thread:0x400fb7e4> : running)
  #1->irb#1 on main (#<Thread:0x40125d64> : stop)
  #2->irb#2 on Foo (#<Thread:0x4011d54c> : stop)
# check if Foo#foo is available
irb(main):005:0> Foo.instance_methods #=> [:foo, ...]

# change the active session
irb(main):006:0> fg 2
# define Foo#bar in the context of Foo
irb.2(Foo):005:0> def bar
irb.2(Foo):006:1>  print "bar"
irb.2(Foo):007:1> end
irb.2(Foo):010:0>  Foo.instance_methods #=> [:bar, :foo, ...]

# change the active session
irb.2(Foo):011:0> fg 0
irb(main):007:0> f =  #=> #<Foo:0x4010af3c>
# invoke a new session with the context of f (instance of Foo)
irb(main):008:0> irb f
# list open sessions
irb.3(<Foo:0x4010af3c>):001:0> jobs
  #0->irb on main (#<Thread:0x400fb7e4> : stop)
  #1->irb#1 on main (#<Thread:0x40125d64> : stop)
  #2->irb#2 on Foo (#<Thread:0x4011d54c> : stop)
  #3->irb#3 on #<Foo:0x4010af3c> (#<Thread:0x4010a1e0> : running)
# evaluate
irb.3(<Foo:0x4010af3c>):002:0> foo #=> 1 => nil
# evaluate
irb.3(<Foo:0x4010af3c>):003:0> bar #=> bar => nil
# kill jobs 1, 2, and 3
irb.3(<Foo:0x4010af3c>):004:0> kill 1, 2, 3
# list open sessions, should only include main session
irb(main):009:0> jobs
  #0->irb on main (#<Thread:0x400fb7e4> : running)
# quit irb
irb(main):010:0> exit

frozen_string_literal: false

frame.rb -
    $Release Version: 0.9$
    by Keiju ISHITSUKA(Nihon Rational Software Co.,Ltd)

frozen_string_literal: false

frozen_string_literal: false

output-method.rb - output methods used by irb
    $Release Version: 0.9.6$
    by Keiju ISHITSUKA(

frozen_string_literal: false DO NOT WRITE ANY MAGIC COMMENT HERE.



Public Class Methods

CurrentContext() click to toggle source

The current IRB::Context of the session, see ::conf

irb(main):001:0> IRB.CurrentContext.irb_name = "foo"
foo(main):002:0> IRB.conf[:MAIN_CONTEXT].irb_name #=> "foo"
               # File irb.rb, line 383
def IRB.CurrentContext
JobManager() click to toggle source

The current JobManager in the session

               # File irb/ext/multi-irb.rb, line 176
def IRB.JobManager
conf() click to toggle source

Displays current configuration.

Modifying the configuration is achieved by sending a message to ::conf.

See Configuration at IRB for more information.

               # File irb.rb, line 366
def IRB.conf
default_src_encoding() click to toggle source
               # File irb/src_encoding.rb, line 4
def self.default_src_encoding
  return __ENCODING__
draw() click to toggle source
               # File irb/easter-egg.rb, line 55
def draw
  @data.each {|row| row.fill(0) }
  yield {|row| {|n| " ',;"[n] }.join }.join("\n")
initialize_tracer() click to toggle source

initialize tracing function

               # File irb/ext/tracer.rb, line 30
def IRB.initialize_tracer
  Tracer.verbose = false
  Tracer.add_filter {
    |event, file, line, id, binding, *rests|
    /^#{Regexp.quote(@CONF[:IRB_LIB_PATH])}/ !~ file and
      File::basename(file) != "irb.rb"
irb(file = nil, *main) click to toggle source

Creates a new IRB session, see

The optional file argument is given to, along with the workspace created with the remaining arguments, see

               # File irb/ext/multi-irb.rb, line 189
def IRB.irb(file = nil, *main)
  workspace =*main)
  parent_thread = Thread.current
  Thread.start do
      irb =, file)
      print "Subirb can't start with context(self): ", workspace.main.inspect, "\n"
      print "return to main irb\n"
    @CONF[:IRB_RC].call(irb.context) if @CONF[:IRB_RC]
    @JobManager.current_job = irb
      system_exit = false
      catch(:IRB_EXIT) do
    rescue SystemExit
      system_exit = true
      unless system_exit
        if @JobManager.current_job == irb
          if parent_thread.alive?
            @JobManager.current_job = @JobManager.irb(parent_thread)
            @JobManager.current_job = @JobManager.main_irb
  @JobManager.current_job = @JobManager.irb(Thread.current)
irb_abort(irb, exception = Abort) click to toggle source

Aborts then interrupts irb.

Will raise an Abort exception, or the given exception.

               # File irb.rb, line 415
def IRB.irb_abort(irb, exception = Abort)
  if defined? Thread
    irb.context.thread.raise exception, "abort then interrupt!"
    raise exception, "abort then interrupt!"
irb_at_exit() click to toggle source

Calls each event hook of ::conf when the current session quits.

               # File irb.rb, line 403
def IRB.irb_at_exit
irb_exit(irb, ret) click to toggle source

Quits irb

               # File irb.rb, line 408
def IRB.irb_exit(irb, ret)
  throw :IRB_EXIT, ret
start(ap_path = nil) click to toggle source

Initializes IRB and creates a new Irb.irb object at the TOPLEVEL_BINDING

               # File irb.rb, line 388
def IRB.start(ap_path = nil)
  STDOUT.sync = true
  $0 = File::basename(ap_path, ".rb") if ap_path


    irb =, @CONF[:SCRIPT])
    irb =
version() click to toggle source

Returns the current version of IRB, including release version and last updated date.

               # File irb.rb, line 372
def IRB.version
  if v = @CONF[:VERSION] then return v end

  @CONF[:VERSION] = format("irb %s (%s)", @RELEASE_VERSION, @LAST_UPDATE_DATE)