tempfile

On certain platforms, you must explicitly define the temporary directory to avoid panics or to ensure files are stored in the correct location:

• WASI P1/P2: Does not define a default temporary directory. You must call tempfile::env::override_temp_dir with a valid directory, otherwise temporary file creation will panic.
• Android: You may need to override the temporary directory to point to your application's per-app cache directory.

Use tempfile::env::override_temp_dir to set the path.

Add tempfile to your Cargo.toml dependencies. The minimum required Rust version is 1.63.0.

[dependencies]
tempfile = "3"

A NamedTempFile provides a file that has a visible name on the filesystem. This is useful when a child process or external tool needs to access the file by its path.

Security Warning: Using named files can be insecure on some platforms if a temporary file cleaner unlinks the file and an attacker replaces it with a different file before you re-open it. For maximum security, use tempfile() (unnamed) unless a name is strictly required.

use tempfile::NamedTempFile;
use std::io::Write;

let mut file = NamedTempFile::new()?;
writeln!(file, "Brian was here. Briefly.")?;

Because TempDir and NamedTempFile rely on destructors for cleanup, passing them into functions that take AsRef<Path> can cause them to be dropped prematurely if the function consumes the value.

Incorrect: Moving the object into a function that consumes it. Correct: Passing a reference to the object so the destructor runs only after the function completes.

use tempfile::tempdir;
use std::process::Command;

// Create a directory inside of `env::temp_dir()`.
let temp_dir = tempdir()?;

// Spawn the `touch` command inside the temporary directory and collect the exit status
// Note that `temp_dir` is **not** moved into `current_dir`, but passed as a reference
let exit_status = Command::new("touch").arg("tmp").current_dir(&temp_dir).status()?;
assert!(exit_status.success());

# Ok::<(), std::io::Error>(())

Use tempfile::tempfile() to create a new temporary file. The file is automatically deleted when the file handle is closed (depending on the OS and implementation details).

use std::fs::File;
use std::io::{Write, Read, Seek, SeekFrom};

fn main() {
    // Write
    let mut tmpfile: File = tempfile::tempfile().unwrap();
    write!(tmpfile, "Hello World!").unwrap();

    // Seek to start
    tmpfile.seek(SeekFrom::Start(0)).unwrap();

    // Read
    let mut buf = String::new();
    tmpfile.read_to_string(&mut buf).unwrap();
    assert_eq!("Hello World!", buf);
}

The tempfile crate supports a wide range of operating systems:

• Linux: Android, Linux
• BSDs: DragonFly BSD, FreeBSD, MidnightBSD, NetBSD, OpenBSD
• Illumos: OpenIndiana, OmniOS
• MacOS: ios, watchos, visionos, etc.
• RedoxOS
• Wasm: WASI P1 & P2, Wasm (build and link only)
• Windows

Platform-specific Notes

• Android, RedoxOS, Wasm, and WASI require the latest stable Rust compiler.
• WASI P1/P2 does not define a default temporary directory and does not have file permissions.
• BSD/Illumos targets are not tested for compatibility with older Rust compilers.

Use tempfile::tempdir_in(dir) to create a new temporary directory inside a specific existing directory. The directory will be automatically deleted when the TempDir is dropped.

Returns an io::Result<TempDir>.

use tempfile::tempdir_in;
use std::fs::File;
use std::io::Write;

// Create a directory inside of the current directory.
let tmp_dir = tempdir_in(".")?;

let file_path = tmp_dir.path().join("my-temporary-note.txt");
let mut tmp_file = File::create(file_path)?;
writeln!(tmp_file, "Brian was here. Briefly.")?;

// `tmp_dir` goes out of scope, the directory as well as
// `tmp_file` will be deleted here.
drop(tmp_file);
tmp_dir.close()?;
# Ok::<(), std::io::Error>(())

Use reopen() to get a new file handle to the same file that a NamedTempFile manages. This is more secure than File::open(path) because it guarantees you are opening the exact same file, even if a temporary file cleaner has unlinked the original path.

use tempfile::NamedTempFile;

let file = NamedTempFile::new()?;
let another_handle = file.reopen()?;

Constructs a SpooledTempFile that will be backed by a file in the specified directory once it rolls over to disk. This is recommended if your default OS temporary directory is an in-memory filesystem and you require disk-backed storage.

Note: The specified path is not checked until the file is actually rolled over to disk. If the directory is not writable, writes will fail once max_size is reached.

use tempfile::spooled_tempfile_in;
use std::path::Path;

let mut file = spooled_tempfile_in(1024, "/var/tmp");