Get the Current Working Directory Absolute Path in Ruby

You will learn the difference between Ruby’s current working directory and the location of a Ruby source file. You will also learn the simplest, portable way to get the current directory’s absolute path: Dir.pwd (or its alias, Dir.getwd).

The current working directory (often shortened to CWD) is the directory Ruby treats as the starting point for relative paths.

For example, if the working directory is:

C:/Users/Ada/projects/inventory

then this relative path:

"data/items.json"

is interpreted relative to that directory.

Use Dir.pwd to get the current working directory as an absolute path:

Dir.pwd

pwd means print working directory, following the same convention as the shell command.

This works in Ruby scripts and in irb, and it is portable across Windows, macOS, and Linux. Ruby returns paths in the format appropriate for the current operating system.

File.expand_path(__FILE__) answers a different question: it resolves the path of the Ruby file currently being executed. It does not necessarily return the working directory. In irb, there is no ordinary source file corresponding to the typed expression, so __FILE__ is not the right tool for finding the directory where the session started.

Think of the current working directory as Ruby’s current room.

• Dir.pwd asks: “Which room am I currently standing in?”
• A relative path such as "notes.txt" means: “Find notes.txt in this room.”
• File.expand_path(__FILE__) asks: “Where is the document I am currently reading from?”

A program can be started from one directory while its source file lives in another. Those are separate locations, so choose the method based on which location you need.

The primary syntax is:

Dir.pwd

Example in irb:

irb(main):001> Dir.pwd
=> "C:/Users/Ada/projects/inventory"

Dir.getwd is an alias for the same operation:

Dir.getwd
# => "C:/Users/Ada/projects/inventory"

You can also expand the special relative path ".", which means “the current directory”:

File.expand_path(".")
# => "C:/Users/Ada/projects/inventory"

For this specific task, prefer Dir.pwd because it directly expresses your intent.

To create an absolute path for a file inside the current directory, use File.expand_path with the file name:

config_path = File.expand_path("config/settings.yml")
puts config_path
# C:/Users/Ada/projects/inventory/config/settings.yml

Consider this Ruby code:

puts Dir.pwd
puts File.expand_path("reports/today.txt")

Suppose Ruby was started in:

C:/Users/Ada/projects/inventory

Execution proceeds as follows:

1. Dir.pwd asks the operating system for Ruby’s current working directory.
2. Ruby receives C:/Users/Ada/projects/inventory and prints it.
3. File.expand_path("reports/today.txt") receives a relative path.
4. Ruby combines it with the current working directory.
5. Ruby normalizes the result and prints:

C:/Users/Ada/projects/inventory/reports/today.txt

File.expand_path calculates a path string. It does not require reports/today.txt to already exist.

Common uses for the current working directory include:

• Command-line scripts: Read files that the user placed in the directory where they ran the command.
• Data imports: Resolve a relative input path such as "customers.csv" to an absolute path for logging or diagnostics.
• Build and automation scripts: Locate project-relative files when a task is intentionally run from the project root.
• Test tools: Display the complete path of generated reports and temporary output.
• Developer tools: Show users where a command is operating before it creates, modifies, or deletes files.

Example: report where an export is written.

output = File.expand_path("output/report.csv")
puts "Writing report to: #{output}"

In real projects, developers distinguish carefully between paths relative to the working directory and paths relative to the source file.

Working-directory-relative paths

Use these when a command is designed to run from a directory chosen by the user:

input_path = File.expand_path(ARGV.fetch(0, "input.json"))

unless File.file?(input_path)
  warn "Input file not found: #{input_path}"
  exit 1
end

This validates the resolved absolute path before processing it.

Source-file-relative paths

Use these when a library or script must find files shipped alongside its own code, regardless of where the command was run:

SCRIPT_DIR = __dir__
template_path = File.join(SCRIPT_DIR, "templates", "email.txt")

__dir__ is usually clearer than File.dirname(__FILE__) for this purpose.

Temporarily changing directories

Ruby can run a block in another directory and automatically return afterward:

Dir.chdir("C:/Users/Ada/projects/inventory") do
  puts Dir.pwd
  # Work with relative paths here.
end

Using the block form avoids accidentally leaving the process in the wrong directory.

Using __FILE__ to find the working directory

File.expand_path(__FILE__)

This resolves the current Ruby file’s path, not the directory where the process was launched. In an interactive session, use Dir.pwd instead.

Assuming Dir.new(".") is needed

Dir.new(".").path

This can return ".", which is still a relative path. It creates a directory object, but it is unnecessary when all you need is the working directory.

Use:

Dir.pwd

Using unrelated file-copy APIs

CopyFile.new(Dir.new(".").path).expand

CopyFile is not the standard Ruby API for resolving a directory path. Constructing an object that expects a file or requires access can trigger errors such as Permission denied. Path resolution does not require opening, copying, or reading a directory.

Confusing an absolute path with an existing path

File.expand_path("missing/file.txt")

This returns an absolute string even if the file does not exist. Check separately when existence matters:

path = File.expand_path("missing/file.txt")
puts File.exist?(path)
# false

Depending on the working directory unintentionally

A script may work in one terminal directory and fail in another. If a resource belongs to the application itself, anchor it to the source file with __dir__, not Dir.pwd.

A useful rule is:

• Need the directory Ruby was started in? Use Dir.pwd.
• Need the directory containing this .rb file? Use __dir__.
• Need to convert a path string to an absolute path? Use File.expand_path.

# Current working directory (absolute path)
Dir.pwd

# Alias for Dir.pwd
Dir.getwd

# Expand the current directory explicitly
File.expand_path(".")

# Expand a relative file path from the current directory
File.expand_path("logs/app.log")

# Directory containing the current Ruby source file
__dir__

# Absolute path of the current Ruby source file
File.expand_path(__FILE__)

# Change the working directory for a block
Dir.chdir("path/to/directory") do
  puts Dir.pwd
end

Key rules:

• Dir.pwd works in both scripts and irb.
• Relative paths depend on the current working directory.
• File.expand_path resolves a path but does not verify that it exists.
• Use __dir__ when files must be located relative to the source code rather than the launch location.

How do I get the current directory in Ruby?

Call Dir.pwd. It returns the current working directory as an absolute path.

Dir.pwd

Does Dir.pwd work in irb on Windows?

Yes. It works in irb, scripts, Windows, macOS, and Linux.

What is the difference between Dir.pwd and File.expand_path(".")?

Both produce the current directory’s absolute path. Dir.pwd is more direct because it explicitly asks for the working directory. File.expand_path is more useful when expanding arbitrary relative paths.

Is Dir.getwd different from Dir.pwd?

No. Dir.getwd is an alias for Dir.pwd.

Why is File.expand_path(__FILE__) not the same as Dir.pwd?

__FILE__ identifies the source file Ruby is evaluating, while Dir.pwd identifies the directory from which the Ruby process is currently operating. They can be different.

Does File.expand_path check whether a file exists?

No. It only resolves and normalizes the path string. Use File.exist?, File.file?, or File.directory? to check the filesystem.

How can I find the directory containing my Ruby script?

Use __dir__ inside the script:

puts __dir__

This is often the correct choice for files packaged with the script.

• Relative and absolute paths — Understand how paths are interpreted from the working directory.
• File.expand_path — Convert relative paths into normalized absolute path strings.
• __FILE__ and __dir__ — Locate the current Ruby source file and its containing directory.
• Dir.chdir — Change the process working directory temporarily or permanently.
• File.exist?, File.file?, and File.directory? — Verify whether resolved paths exist and what they represent.
• File.join — Build paths safely from separate directory and file components.