# File Allocation Strategies in Motrix: Performance Comparison and Configuration Guide

> Explore Motrix file allocation strategies: none, prealloc, trunc, and falloc. Understand their performance impact and find the best configuration for your needs.

- Repository: [Dr_rOot/Motrix](https://github.com/agalwood/Motrix)
- Tags: performance
- Published: 2026-08-19

---

**Motrix exposes four file allocation strategies—`none`, `prealloc`, `trunc`, and `falloc`—that control how the underlying aria2 engine reserves disk space, with `falloc` delivering optimal Linux performance by preventing fragmentation without zero-fill overhead, while `none` offers minimal startup latency at the risk of file system fragmentation.**

Motrix delegates actual download operations to the aria2 backend, exposing critical disk management settings through its **Engine Tuning** configuration panel. The **file allocation strategy** determines how the downloader reserves storage space before writing data, directly impacting download reliability, disk fragmentation patterns, and initial startup time. These settings are defined in the `EngineSettings.fileAllocation` schema and translated into aria2 command-line arguments within the Motrix codebase.

## Understanding Motrix File Allocation Settings

In Motrix, file allocation behavior is governed by the `fileAllocation` property within the `EngineSettings` schema. This value is strictly validated against a Zod enum defined in [[`src/shared/schemas/engine-settings.ts`](https://github.com/agalwood/Motrix/blob/main/src/shared/schemas/engine-settings.ts)](https://github.com/agalwood/Motrix/blob/main/src/shared/schemas/engine-settings.ts#L34), which accepts only four specific strings: `none`, `prealloc`, `trunc`, and `falloc`.

When a download starts, Motrix instantiates the `Aria2ConfigBuilder` class to construct the command-line arguments passed to the aria2 process. At line 116 of [[`src/core/engine/aria2/aria2-config-builder.ts`](https://github.com/agalwood/Motrix/blob/main/src/core/engine/aria2/aria2-config-builder.ts)](https://github.com/agalwood/Motrix/blob/main/src/core/engine/aria2/aria2-config-builder.ts#L116), the builder injects the `--file-allocation=` flag, mapping the user's stored preference directly to aria2's native configuration.

## The Four File Allocation Strategies Available in Motrix

### none

The **none** strategy performs no pre-allocation. aria2 writes incoming data chunks immediately, allowing the file to grow dynamically as bytes arrive. This eliminates the initial delay of reserving storage space and minimizes CPU usage during download startup. However, because the file system allocates blocks on-demand, large files often become physically fragmented across the disk, and the download may fail mid-way if the drive runs out of space.

### prealloc

The **prealloc** strategy reserves the full file size upfront using `ftruncate` or equivalent system calls, creating a contiguous block of storage before any data arrives. This approach guarantees that sufficient disk space exists for the entire download and significantly reduces fragmentation on most file systems. The trade-off is a startup delay proportional to file size, as the operating system may need to zero-fill the allocated blocks to ensure data security.

### trunc

The **trunc** strategy executes a single `truncate` operation to set the final file size immediately, similar to `prealloc` but without mandatory zero-filling. This method still mitigates fragmentation by establishing the full file extent upfront while offering slightly faster initialization than `prealloc`. It serves as a middle ground between the safety of pre-allocation and the speed of lazy allocation.

### falloc

The **falloc** strategy invokes the native Linux `fallocate` system call, which reserves disk space without zero-filling the contents. This provides the fragmentation resistance of `prealloc` with near-instantaneous allocation speed, making it the most efficient option on Linux systems. On non-Linux platforms (Windows or macOS), aria2 falls back to the `none` behavior when `falloc` is specified, meaning performance characteristics revert to dynamic allocation.

## Performance Impact and Use Cases

**Large sequential downloads** (such as ISO images or video files) benefit most from `prealloc` or `falloc`. These strategies prevent the performance degradation caused by file system fragmentation during sustained write operations and eliminate the risk of "disk full" errors after partially completing a multi-gigabyte transfer.

**Small or numerous short downloads** typically perform best with `none`. The overhead of allocating space for hundreds of small files often exceeds any performance gain from reduced fragmentation, making immediate-write behavior more efficient for batch operations.

**Linux users** should prefer `falloc` for large files, as it combines the space guarantee of pre-allocation with zero CPU overhead. Windows and macOS users must choose between `prealloc` (for fragmentation control) or `none` (for speed), since `falloc` degrades to `none` on unsupported platforms.

## How to Configure File Allocation in Motrix

### Configuring via the User Interface

The allocation strategy is exposed in the **Engine Tuning** section of the Settings panel. The React component in [[`src/renderer/routes/settings/cards/engine-tuning-section.tsx`](https://github.com/agalwood/Motrix/blob/main/src/renderer/routes/settings/cards/engine-tuning-section.tsx)](https://github.com/agalwood/Motrix/blob/main/src/renderer/routes/settings/cards/engine-tuning-section.tsx#L38-L53) renders a dropdown selector populated by the `fileAllocationOptions` array, mapping user-friendly labels to the four enum values. When a user selects a new strategy, the component updates the `EngineSettings` store, which persists across application restarts.

```tsx
// src/renderer/routes/settings/cards/engine-tuning-section.tsx
<Select
  name="engine.fileAllocation"
  label={t('settings.downloads.disk.fileAllocation')}
  description={t('settings.downloads.disk.fileAllocationDesc')}
  items={fileAllocationOptions}   // Defined at lines 38-53
/>

```

### Programmatic Configuration

Developers or advanced users can modify the allocation strategy programmatically using the `Aria2ConfigBuilder` class. The following example demonstrates how to construct aria2 arguments with a specific allocation method:

```typescript
import { Aria2ConfigBuilder } from '@core/engine/aria2/aria2-config-builder';
import type { EngineSettings } from '@shared/types/settings';

const settings: EngineSettings = {
  // ... other engine options ...
  fileAllocation: 'falloc',          // Options: 'none', 'prealloc', 'trunc', 'falloc'
  // ...
};

const builder = new Aria2ConfigBuilder(
  '/path/to/template/aria2.conf',
  '/path/to/user/config/dir'
);

const args = builder.buildArgs(settings, true, null, { download: 0, upload: 0 });
console.log(args.join(' '));
// Output includes: --file-allocation=falloc

```

The `buildArgs` method processes the `fileAllocation` value at line 116 of [`aria2-config-builder.ts`](https://github.com/agalwood/Motrix/blob/main/aria2-config-builder.ts), ensuring the flag is correctly formatted for the aria2 binary.

## Summary

- Motrix manages file allocation through four distinct strategies defined in [`src/shared/schemas/engine-settings.ts`](https://github.com/agalwood/Motrix/blob/main/src/shared/schemas/engine-settings.ts): `none`, `prealloc`, `trunc`, and `falloc`.
- The `Aria2ConfigBuilder` class translates these settings into `--file-allocation=` command-line arguments at runtime.
- `falloc` provides optimal performance on Linux by avoiding zero-fill while preventing fragmentation, but falls back to `none` on Windows and macOS.
- `prealloc` ensures contiguous disk allocation at the cost of initialization time, making it ideal for large, single-file downloads.
- `none` minimizes startup overhead but risks mid-download failures and fragmentation, suitable for small or temporary files.

## Frequently Asked Questions

### What is the fastest file allocation strategy in Motrix?

The **none** strategy offers the fastest download startup because it eliminates the initial overhead of reserving disk space, allowing aria2 to write data immediately as it arrives from the network. However, this speed comes at the cost of potential file system fragmentation and the risk of running out of disk space during large downloads.

### Does file allocation affect download speed?

File allocation primarily affects **initial startup time** and **long-term disk I/O efficiency** rather than network throughput. Strategies like `prealloc` and `falloc` can improve sustained write performance for large files by ensuring contiguous disk blocks, whereas `none` may cause performance degradation over time due to fragmentation, particularly on mechanical hard drives.

### Why is falloc not available on Windows or macOS?

The **falloc** strategy depends on the Linux-specific `fallocate` system call, which reserves space without zero-filling. Windows and macOS lack direct equivalents that aria2 can leverage for this specific behavior. When `falloc` is specified on non-Linux systems, aria2 automatically falls back to the `none` strategy, as implemented in the engine's platform detection logic referenced in the configuration builder.

### Which allocation strategy should I use for large files?

For large files exceeding several gigabytes, use **falloc** on Linux systems or **prealloc** on Windows and macOS. These strategies ensure the entire file size is reserved before downloading begins, preventing "insufficient disk space" errors mid-download and minimizing fragmentation that could slow down playback or access speeds for large media files.