Rust Lang

How to Read Files in Rust Language

The ability and functionality to read files are as simple as clicking a button in a graphical interface. Although implementing file read operations in a program is not as straightforward as a button click, it is relatively easy.

Hello Rustaceans! This guide will teach you to read files using the Rust programming language.

Sample File

Although you can read a file stored in any location of your filesystem, for illustration, we will keep our sample file in the current working directory.

Start by generating a new project as:

$ cargo new rust_read_file

Next, navigate into the directory as:

$ cd rust_read_file/src

Inside the src directory, create a sample test file.

$ touch sample.txt
echo "Hi, I am inside the sample.txt file" > sample.txt

The previous commands will create a new text file and write it to the sample.txt file.

Read File as a String

The simplest method to read a file is to read it as a string. This method loads the file’s contents into memory and allows you to manipulate the file.

We can do this using the read_to_string method from the Read module of the io package. An example is provided below:

use std::fs::File;

use std::io::Read;

fn main() {

let mut file = File::open("sample.txt")

.expect("Error opening file");

let mut data = String::new();

file.read_to_string(&mut data)

.expect("Error reading file");

println!("{}", data);


In the previous code, we started by importing the required modules for handling files. These include the fs::File and io::Read from the standard library.

The first statement in the main function creates a mutable handle to the file we wish to open. We do this by using the File::open method and pass the name of the file as the argument.

The second statement holds a mutable variable containing the data of the file. We create this as an empty string to which we can then load the data of the file.

Finally, we call the read_to_string method to read the file and pass a mutable reference to the data variable. This will write the contents of the file to the empty string.

Then, we can print the contents of the file using the println! method.

Running the previous code should return the content in the sample.txt

$ cargo run

Hi, I am inside the sample.txt

Read File Line by Line

We can read a file line by line using the lines() method. Consider the example code shown below:

use std::fs::File;

use std::io::BufReader;

use std::io::prelude::*;

fn main() -> std::io::Result<()>{

let file = File::open("sample.txt")

.expect("Error opening file");

let mut reader = BufReader::new(file);

for line in reader.lines() {

println!("{}", line?);




The previous code uses the File::open() method to read the sample.txt. The following line creates a mutable reader using the BufReader::new and passes the file object. Then, we iterate the lines in the file and print the contents.


In this article, we covered two major methods of reading files in the Rust programming language. Although the code implemented in this article works great for small files, it can quickly get complex with extensive files. Hence, consider organizing the read operations into standalone functions. This can help reduce the load on the main function. We hope you found this article helpful. Check the other Linux Hint articles for more tips and information.

About the author

John Otieno

My name is John and am a fellow geek like you. I am passionate about all things computers from Hardware, Operating systems to Programming. My dream is to share my knowledge with the world and help out fellow geeks. Follow my content by subscribing to LinuxHint mailing list