How to Require All Files from a Directory in Ruby

By the end of this page, you will understand how Ruby loads files, how to require multiple files from a directory using Dir and glob patterns, when to use require versus require_relative, why file load order matters, and how to avoid common mistakes when auto-loading files in a project.

Ruby does not have a built-in single command like “require this whole directory.” Instead, developers usually combine:

• Dir[] or Dir.glob to find matching files
• require or require_relative to load each file

A common pattern looks like this:

Dir[File.join(__dir__, 'my_folder', '*.rb')].sort.each { |file| require file }

This works because:

• Dir[...] returns a list of file paths matching a pattern
• *.rb means “all Ruby files in this directory”
• each loops through those files
• require loads each file once

Why this matters

In real Ruby projects, code is often split across multiple files:

• classes
• modules
• service objects
• configuration files
• initializers

Manually writing many require lines becomes repetitive and hard to maintain. Requiring files dynamically can keep setup code shorter and easier to update.

Important detail: load order

The biggest issue is not how to load all files, but in what order they are loaded.

Think of a directory like a shelf full of books.

• Dir[...] is you looking across the shelf and collecting all books that match a label, such as all files ending in .rb
• require is opening each book and adding its contents to your program
• .sort is arranging the books in a predictable order before reading them

If you read Book B before Book A, and Book B refers to something explained only in Book A, you get confused. Ruby gets confused the same way when dependencies are loaded in the wrong order.

Basic syntax

Dir[File.join(__dir__, 'lib', '*.rb')].sort.each do |file|
  require file
end

What each part does

• __dir__ gives the directory of the current file
• File.join(...) builds a safe path
• *.rb matches all Ruby files
• .sort ensures a consistent load order
• require file loads each file once

Example: load all files in a folder

Suppose your project looks like this:

project/
  main.rb
  helpers/
    math_helper.rb
    string_helper.rb

In main.rb:

Dir[File.join(__dir__, 'helpers', '*.rb')].sort.each do |file|
  require file

Consider this code:

Dir[File.join(__dir__, 'models', '*.rb')].sort.each do |file|
  require file
end

Assume the models folder contains:

models/
  user.rb
  order.rb

Step by step

1. __dir__

Ruby gets the directory of the current file.

If the current file is:

/app/main.rb

then __dir__ is:

/app

2. File.join(__dir__, 'models', '*.rb')

Ruby builds this pattern:

/app/models/*.rb

3. Dir[...]

Ruby finds matching files:

Plugin systems

A Ruby application may load all plugin files from a plugins/ directory at startup.

Service objects

A project may store many service classes in services/ and require them during boot.

CLI tools

Command-line apps often load command classes from a folder so new commands can be added easily.

Initializers

Some apps load configuration or setup files from an initializers/ directory.

Small libraries and scripts

In a personal project or utility script, auto-requiring all helper files can reduce setup boilerplate.

In real projects, developers usually use this pattern carefully.

Common patterns

Explicit boot file

A project may have one file like environment.rb or boot.rb that requires all needed files.

Dir[File.join(__dir__, 'services', '*.rb')].sort.each { |file| require file }

Guarding load order with naming

Some teams prefix files with numbers or clear names when order matters:

01_config.rb
02_database.rb
03_models.rb

This is simple, but can become fragile.

Prefer explicit requires for dependencies

If one class clearly depends on another, many developers prefer:

require_relative 'user'
require_relative 'order'

This makes dependencies obvious.

Recursive loading for library folders

Libraries sometimes load all files under lib/:

Dir[.join(__dir__, , , )].sort.each { ||  file }

1. Forgetting to sort files

Without sorting, file order may be inconsistent or unclear.

Broken example:

Dir[File.join(__dir__, 'lib', '*.rb')].each do |file|
  require file
end

Better:

Dir[File.join(__dir__, 'lib', '*.rb')].sort.each do |file|
  require file
end

2. Using relative strings with require

This may fail if the working directory is different from what you expect.

Broken example:

require 'helpers/math_helper'

If that path is not on Ruby's load path, it will fail.

Better:

require_relative 'helpers/math_helper'

or:

require vs require_relative

# Load all Ruby files in one directory
Dir[File.join(__dir__, 'folder', '*.rb')].sort.each do |file|
  require file
end

# Load all Ruby files recursively
Dir[File.join(__dir__, 'folder', '**', '*.rb')].sort.each do |file|
  require file
end

# Load one nearby file
require_relative 'folder/my_file'

Quick rules

• Use require to load a file once
• Use require_relative for a specific local file
• Use Dir[] or Dir.glob to find matching files
• Use .sort for predictable order
• Use *.rb to match Ruby files only
• Use **/*.rb for nested folders
• Prefer explicit requires when dependency order matters

Common pattern

What is the best way to require all files from a directory in Ruby?

Usually, use Dir[File.join(__dir__, 'folder', '*.rb')].sort.each { |file| require file }. This is a common and simple pattern.

Should I use require or require_relative in Ruby?

Use require_relative for one known local file. Use require when you already have a full path or when loading gems and standard libraries.

Why do people sort files before requiring them?

Sorting creates a predictable load order. Without it, dependencies may break unexpectedly.

Can I require files from subdirectories too?

Yes. Use a recursive glob such as **/*.rb.

Does require load the same file more than once?

Normally, no. Ruby tracks required files and skips reloading them.

Is auto-requiring every file always a good idea?

No. It can hide dependencies and cause order problems. Explicit requires are often better when files depend on each other.

What is the difference between require and load in Ruby?

require loads once. load reads and executes the file every time it is called.

• require — the core Ruby method for loading files once.
• require_relative — useful when loading local files relative to the current file.
• load — related because it also reads Ruby files, but reloads them each time.
• Dir.glob — used to find files matching patterns in directories.
• File.join — helps build portable file paths safely.
• __dir__ — useful for creating paths relative to the current file.
• load path ($LOAD_PATH) — important for understanding how require finds files.
• autoloading — related because some frameworks load files automatically.
• modules and classes — commonly spread across multiple files that need to be required.