# memfile

**Easy RAM disk for Windows.** Create an arbitrarily-sized in-memory volume in
milliseconds and get a **real Windows file path** inside it that **any** application
(VLC, Photos, ImageGlass, Audacity, Python, anything) can read and write.

Backed by [WinFsp](https://github.com/winfsp/winfsp) via a native
Rust PyO3 extension.

## Why

Sometimes you need a file to *exist on the filesystem*, ONLY because some other app
simply doesn't have the ability to open it from a memory location. If you want to write a script or an executable temporarily simply to execute it and then delete it, this is perfect. If you want easy media previews, like images, videos, and support all file formats, this is perfect, just write to the ram disk and have the OS open it in whatever is the default media viewer. Writing any of that to disk both wastes valuable SSD writes AND wastes time since ram is much much faster to write and read from. `memfile` gives you a real path backed entirely by RAM:

```python
import memfile

with memfile.Volume(size_mb=64) as vol:
    path = vol.write("clip.mp4", data)   # real path like R:\clip.mp4
    os.startfile(path)                   # opens in the native player
# volume + its contents vanish on exit — zero disk writes
```

A `Volume` doesn't need a `with` block — a bare one lives like a bare `open()`,
until you `.unmount()` it, drop it, or the process exits (it's auto-reclaimed
on exit, even on a hard kill):

```python
vol = memfile.Volume(size_mb=128)   # stays mounted
...
vol.unmount()                       # or just let the process end
```

### Temp files on RAM

Drop-in replacements for the `tempfile` functions that put the file on a RAM
disk instead of the on-disk system temp dir — same arguments, same return
objects:

```python
import memfile, subprocess, sys, os

with memfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
    f.write("print('hello from RAM')")
    script = f.name                 # e.g. R:\tmpabcd.py — in RAM
subprocess.run([sys.executable, script])
os.remove(script)
```

Also `memfile.TemporaryFile`, `mkstemp`, `mkdtemp`, `TemporaryDirectory`.

### Mount as a folder (no drive letter)

Instead of a drive letter, a volume can mount at a **folder path**. A folder
mount creates no drive letter and no volume-arrival broadcast, so — unlike a
drive-letter mount — it never wakes idle disks (e.g. a backup HDD spinning up
on every mount), while still being visible across integrity levels. Recommended
for background/elevated services:

```python
with memfile.Volume(size_mb=64, folder=True) as vol:
    print(vol.path)                 # e.g. C:\Users\me\AppData\Local\memfile\mounts\<id>\
    vol.write("clip.mp4", data)
# the folder is created on mount and removed on unmount
```

Pass `folder="C:\\some\\path"` to choose the location (must not already exist,
or be an empty directory).

## Requirements

- Windows (x64)
- [WinFsp](https://winfsp.dev/rel/) (installed automatically) (one-time, requires admin **once**).
  After that, creating and destroying volumes needs no elevation.

## Installation

```
pip install memfile
```

## License

`memfile` is licensed under the **MIT License** (see `LICENSE`).

It links the WinFsp DLL at runtime under the terms of the WinFsp FLOSS License
Exception:

> **WinFsp - Windows File System Proxy, Copyright (C) Bill Zissimopoulos.**
> <https://github.com/winfsp/winfsp>

WinFsp is a separate work (GPLv3 with a FLOSS exception) and must be installed
separately by the end user. `memfile` does not redistribute or modify WinFsp.
