How to List Files in a Directory in Rust

By the end of this page, you will understand how to read directory contents in Rust using std::fs::read_dir, how to extract file names and paths, how to handle errors safely, and how to filter results when you only want files rather than directories.

In Rust, listing the contents of a directory is usually done with std::fs::read_dir.

read_dir returns an iterator over the entries inside a directory. Each entry is represented by a DirEntry, which can give you information such as:

• the full path
• the file name
• metadata about the entry

This matters because many real programs need to inspect folders:

• command-line tools that scan files
• backup scripts
• media organizers
• build systems
• log processors

Unlike Python's os.listdir, Rust makes error handling explicit. That means:

• opening the directory can fail
• reading a specific entry can fail
• converting a file name to a UTF-8 string may fail in some cases

Rust asks you to deal with those possibilities clearly, which leads to safer code.

Think of a directory like a box of labeled items.

• read_dir("./") opens the box
• the iterator lets you pull items out one by one
• each DirEntry is one item label
• you can inspect that label to get the name or full path

So instead of getting one finished list immediately, Rust often gives you a stream of entries that you process step by step.

The basic syntax is:

use std::fs;

fn main() -> std::io::Result<()> {
    for entry in fs::read_dir("./")? {
        let entry = entry?;
        println!("{}", entry.path().display());
    }
    Ok(())
}

What this does

• fs::read_dir("./")? opens the current directory
• it returns an iterator of results
• each entry must also be unwrapped with ?
• entry.path() gets the full path
• .display() formats the path for printing

Getting only file names

use std::fs;

fn main() -> std::io::Result<()> {
    for   fs::()? {
          = entry?;
          = entry.();
        (, file_name.());
    }
    (())
}

Consider this example:

use std::fs;

fn main() -> std::io::Result<()> {
    for entry in fs::read_dir("./")? {
        let entry = entry?;
        println!("{}", entry.file_name().to_string_lossy());
    }
    Ok(())
}

Step by step:

1. fs::read_dir("./")?

   • Rust tries to open the current directory.
   • If it fails, main returns the error immediately.

2. for entry in ...

   • Rust starts looping over the directory entries.
   • Each item is a Result<DirEntry, std::io::Error>.

3. let entry = entry?;

   • If reading this specific entry failed, return the error.
   • Otherwise, extract the DirEntry.

Directory listing is used in many practical situations:

• CLI tools: scan a folder and process every file
• Backup utilities: gather files before copying them elsewhere
• Image or video apps: load media files from a directory
• Log analysis: read all log files in a folder
• Static site generators: find content files to build pages
• Build tools: inspect source directories for compilation inputs

Example: only process .txt files in a folder.

use std::fs;

fn main() -> std::io::Result<()> {
    for entry in fs::read_dir("./")? {
        let entry = entry?;
        let path = entry.path();

        if path.extension().and_then(|ext| ext.to_str()) == Some("txt") {
            println!("Text file: {}", path.display());
        }
    }

    Ok(())
}

This pattern is common in scripts and automation tools.

In real Rust codebases, developers usually do more than just print entries.

Common patterns include:

Guard clauses

Return early if the directory cannot be read:

use std::fs;

fn list_dir(path: &str) -> std::io::Result<()> {
    let entries = fs::read_dir(path)?;

    for entry in entries {
        let entry = entry?;
        println!("{}", entry.path().display());
    }

    Ok(())
}

Filtering only files

use std::fs;

fn main() -> std::io::Result<()> {
    for entry in fs::read_dir("./")? {
        let entry = entry?;
        let path = entry.();

         path.() {
            (, path.());
        }
    }
    (())
}

1. Forgetting that read_dir returns results

Broken code:

use std::fs;

fn main() {
    for entry in fs::read_dir("./") {
        println!("{:?}", entry);
    }
}

Problem:

• fs::read_dir("./") returns a Result<ReadDir, Error>, not an iterator directly.

Correct version:

use std::fs;

fn main() -> std::io::Result<()> {
    for entry in fs::read_dir("./")? {
        println!("{:?}", entry?);
    }
    Ok(())
}

2. Assuming every name is valid UTF-8

Broken code:

  = entry.().().();

use std::fs;

fn main() -> std::io::Result<()> {
    for entry in fs::read_dir("./")? {
        let entry = entry?;
        println!("{}", entry.path().display());
    }
    Ok(())
}

Quick rules

• Use std::fs::read_dir(path) to read a directory.
• It returns Result<ReadDir, std::io::Error>.
• Each item inside the iterator is also a Result<DirEntry, std::io::Error>.
• Use entry.path() for full path.
• Use entry.file_name() for just the file name.
• Use to_string_lossy() for safe string conversion.
• Use path.is_file() to keep only files.
• Use path.is_dir() to keep only directories.

Common patterns

Get file names:

How do I list files in the current directory in Rust?

Use std::fs::read_dir("./") and loop through the returned entries.

What is the Rust equivalent of Python os.listdir()?

The closest equivalent is std::fs::read_dir(). Rust returns an iterator of directory entries rather than a ready-made list of strings.

How do I get only file names and not full paths?

Use entry.file_name() instead of entry.path().

How do I list only regular files in Rust?

Check entry.path().is_file() before processing the entry.

Why does Rust use OsString for file names?

Because file names are not always valid UTF-8 on all operating systems. OsString can represent OS-native file names safely.

Can read_dir fail even after opening the directory?

Yes. Opening the directory may succeed, but reading a specific entry can still fail, which is why each entry is also a Result.

How do I collect directory contents into a vector?

Use a loop with push, or use iterator methods like and .

• std::fs::read_dir — the main API for reading directory contents.
• Path and PathBuf — used to work with file system paths safely.
• Result — important because file system operations can fail.
• Option — often used when checking extensions or optional path parts.
• Iterator — read_dir produces an iterator that you loop over or transform.
• DirEntry — represents one item inside a directory.
• File metadata — useful when checking whether an entry is a file or directory.
• Error handling with ? — the standard way to propagate I/O errors in Rust.