# Are There Limitations to the Number of Files That Can Be Converted in p2r3/convert?

> Discover if p2r3/convert has limits on file conversion. Learn about processing capabilities and enjoy unlimited file conversions without restrictions.

- Repository: [p2r3/convert](https://github.com/p2r3/convert)
- Tags: faq
- Published: 2026-02-19

---

**The p2r3/convert repository does not impose a hard-coded limit on the number of files that can be processed in a single conversion request.**

When working with the open-source `p2r3/convert` tool, understanding potential constraints on batch processing is crucial for planning large-scale conversion workflows. While many conversion utilities enforce artificial caps on file quantities, this repository takes a different approach. The architecture allows unlimited file processing in theory, though real-world **limitations to the number of files that can be converted** effectively depend entirely on your environment's resources.

## Core Architecture: No Hard-Coded Restrictions

The conversion pipeline is designed around a generic handler interface that accepts an array of `FileData` objects without validating array length. In [`src/FormatHandler.ts`](https://github.com/p2r3/convert/blob/main/src/FormatHandler.ts), the `doConvert` method signature receives `inputFiles` as an array and iterates over every entry unconditionally.

Each concrete implementation in `src/handlers/` follows this same contract. Whether processing PNG images, MP4 videos, or SVG graphics, no handler defines a `MAX_FILES` constant or implements guard clauses that reject large collections. The code simply processes what it receives.

## Web UI Implementation

The browser interface uses standard HTML5 APIs that support unlimited multi-file selection. In [`index.html`](https://github.com/p2r3/convert/blob/main/index.html), the file input element includes the `multiple` attribute:

```html
<input type="file" multiple>

```

The event wiring in [`src/main.ts`](https://github.com/p2r3/convert/blob/main/src/main.ts) converts the `FileList` to an array and passes it directly to the conversion engine:

```typescript
const fileInput = document.getElementById('file-input') as HTMLInputElement;
fileInput.addEventListener('change', async () => {
  const files = Array.from(fileInput.files ?? []);
  await convertFiles(files);
});

```

Because the browser handles the file selection and the conversion engine accepts any array size, there is no artificial bottleneck in the UI layer.

## Practical Limitations to Consider

While the codebase imposes no restrictions, several environmental factors create de facto **limitations to the number of files that can be converted** in practice:

- **Browser Memory**: Processing large numbers of high-resolution images, videos, or audio files can exhaust client-side RAM, causing the page to become unresponsive or crash.

- **File Size Constraints**: Individual handlers rely on browser APIs like `FileReader`, `Blob`, and WebAssembly modules. Extremely large individual files may hit browser-specific per-file size caps before quantity becomes an issue.

- **Network and Server Resources**: If the application is deployed with a backend server for processing, server-side upload limits, timeout configurations, and processing queues would impose constraints. However, the current pure-client implementation has no server-side restrictions.

## Programmatic Batch Conversion Example

When using the library programmatically, you can process unlimited files by mapping them to the `FileData` interface:

```typescript
import PNGHandler from './handlers/png.ts';
import { readFile } from './utils.ts';

async function batchConvert(fileList: File[]) {
  const handler = new PNGHandler();
  await handler.init();

  const inputFiles = await Promise.all(
    fileList.map(async f => ({
      name: f.name,
      buffer: await readFile(f),
      mime: f.type,
    }))
  );

  // No length validation occurs here
  const outputs = await handler.doConvert(
    inputFiles,
    handler.supportedFormats![0],
    handler.supportedFormats![0]
  );
  return outputs;
}

```

This pattern applies across all handlers in `src/handlers/`, from image converters to video processors.

## Summary

- The `p2r3/convert` repository contains no hard-coded limits on file quantities in [`src/FormatHandler.ts`](https://github.com/p2r3/convert/blob/main/src/FormatHandler.ts) or any concrete handler implementation.
- The web interface uses standard HTML5 multiple file selection without artificial caps.
- Practical **limitations to the number of files that can be converted** stem from browser memory, individual file sizes, and potential server-side constraints in deployed environments.
- The architecture supports unlimited batch processing as long as the host environment has sufficient resources.

## Frequently Asked Questions

### Is there a maximum file count I can select in the web interface?

No. The file input element in [`index.html`](https://github.com/p2r3/convert/blob/main/index.html) uses the standard `multiple` attribute without a `max` property, and [`src/main.ts`](https://github.com/p2r3/convert/blob/main/src/main.ts) processes all selected files regardless of quantity. The only limits are your browser's memory and performance capabilities.

### Will the conversion crash if I upload thousands of files at once?

Potentially. While the code in [`src/FormatHandler.ts`](https://github.com/p2r3/convert/blob/main/src/FormatHandler.ts) will attempt to process every file in the `inputFiles` array, thousands of large media files can exhaust available RAM. The application does not implement queue-based processing or memory management guards to prevent browser crashes from excessive batch sizes.

### Do individual handlers like the PNG or MP4 converters have different file limits?

No. All handlers in `src/handlers/` inherit the same interface from [`src/FormatHandler.ts`](https://github.com/p2r3/convert/blob/main/src/FormatHandler.ts) and accept the `inputFiles` array without length validation. Whether converting PNG images, MP4 videos, or SVG graphics, none define a `MAX_FILES` constant or implement quantity restrictions.

### Can I implement my own file count limits when using the library programmatically?

Yes. Since the core library imposes no restrictions, you can add validation logic before calling `handler.doConvert()`. Simply check the length of your file array and implement pagination, queuing, or rejection logic based on your specific resource constraints or business requirements.