Difference Between require and include in Ruby

By the end of this page, you will understand that require and include solve different problems in Ruby. require loads code from a file, while include mixes a module's instance methods into a class. You will also see when both are needed together, which is the most common real-world case.

require and include are often confused because they are both used when working with modules, but they do very different jobs.

require: load code from a file

require tells Ruby to load and execute another file once.

require 'json'

This makes the code in that file available to your program. Ruby uses require for standard libraries, gems, and your own files.

If the module or class is defined in another file, Ruby cannot use it until that file is loaded.

include: mix a module into a class

include takes a module and adds its instance methods to a class.

module Greeting
  def hello
    "Hello"
  end
end

class Person
  include Greeting
end

Now instances of can call .

Think of require as bringing a toolbox into the room.

• If the toolbox is still in the garage, you cannot use the tools.
• require brings the toolbox in so Ruby can see it.

Think of include as taking tools from the toolbox and attaching them to your class.

• The toolbox may be present.
• But until you attach the tool, your class does not gain that behavior.

So:

• require = load the file
• include = add module methods to instances of the class

In many cases, you need both: first bring in the toolbox, then attach the tool.

Core syntax

Load a file

require 'json'
require_relative 'greeting'

• require loads libraries or gems by name.
• require_relative loads a file relative to the current file.

Include a module in a class

module Greeting
  def hello
    "Hello"
  end
end

class Person
  include Greeting
end

person = Person.new
puts person.hello

Output:

Hello

Example using both together

Suppose you have a file named greeting.rb:

module Greeting
  def 
    
  

Consider this code:

module Greeting
  def hello
    "Hello"
  end
end

class Person
  include Greeting
end

person = Person.new
puts person.hello

Step-by-step

1. Ruby reads the module definition

module Greeting

Ruby creates a module named Greeting.

2. Ruby defines the hello method inside the module

def hello
  "Hello"
end

At this point, Greeting has an instance method named hello.

3. Ruby reads the class definition

1. Using standard library features

require 'json'

data = JSON.parse('{"name":"Ava"}')
puts data["name"]

Here, require loads Ruby's JSON library.

2. Sharing behavior across multiple classes

module Trackable
  def track
    "Tracking activity"
  end
end

class User
  include Trackable
end

class Order
  include Trackable
end

Here, include avoids duplicating the track method in multiple classes.

3. Loading app files in a multi-file project

require_relative 'trackable'

class User
   

In real projects, developers usually use require for loading dependencies and include for composing behavior.

Common pattern: load then mix in

require_relative 'authenticatable'

class User
  include Authenticatable
end

This is the normal pattern when a module is defined in another file.

Organizing shared behavior

Modules are often used for:

• formatting helpers
• authentication logic
• validation helpers
• logging behavior
• reusable business rules

Why developers prefer modules

Instead of copying methods into many classes, developers define a module once and include it where needed.

Related pattern: guard against missing dependencies

If you try to include a module before loading it, your code fails early with a NameError. This is actually helpful because it tells you the dependency was not loaded.

Configuration and library usage

In larger Ruby apps, require is also used to load:

• gems
• framework components
• configuration files
• custom classes and modules

is not for loading files. It is only for mixing module methods into a class or module.

Mistake 1: Thinking require and include are interchangeable

They are not.

• require loads a file
• include adds module methods to a class

Broken idea:

class Person
  require 'greeting'
end

This may load a file, but it does not mix module methods into Person.

Mistake 2: Including a module before it is loaded

Broken code:

class Person
  include Greeting
end

If Greeting has not been defined yet, Ruby raises an error.

Fix:

require_relative 'greeting'

class Person
  include Greeting

require vs

Quick reference

Load code

require 'json'
require_relative 'my_module'

• require loads a library or gem
• require_relative loads a local file by relative path
• A file is generally loaded only once by require

Mix in a module

module MyModule
  def greet
    "Hi"
  end
end

class MyClass
  include MyModule
end

• include adds module instance methods to class instances
• It does not load the file where the module is defined

Common pattern

require_relative 'my_module'

class MyClass
  include 

Do I need both require and include in Ruby?

Often, yes. If the module is in another file, you usually require or require_relative the file first, then include the module in your class.

What does require do in Ruby?

require loads and executes another file so its classes, modules, and code become available.

What does include do in Ruby?

include mixes a module's instance methods into a class so objects of that class can use them.

Can I use require instead of include?

No. require only loads the file. It does not add module methods to your class.

Can I use include without require?

Only if the module has already been loaded or defined earlier in the same program.

Should I use require or for my own files?

• extend — related because it mixes module methods into an object or class as singleton methods instead of instance methods.
• require_relative — related because it is commonly used to load your own Ruby files before including modules.
• modules in Ruby — related because include works specifically with modules.
• instance methods — related because include adds module methods as instance methods.
• class methods — related because learners often compare include with extend when deciding where methods should live.
• method lookup path — related because Ruby searches included modules when resolving method calls.
• mixins — related because include is Ruby's main mixin mechanism.