Motrix Development Roadmap: From v2 Beta to Stable Release and Beyond

The Motrix development roadmap progresses from the current v2 beta phase to a stable Electron-React release, followed by a planned Rust engine rewrite and expanded plugin ecosystem.

Motrix is a modern, open-source download manager built on Electron and React. According to the agalwood/Motrix repository, the project follows a clearly documented multi-phase roadmap that transitions the application from its current beta state toward a high-performance Rust core while maintaining a clean plugin architecture.

Current Phase: v2 Beta Migration

The project is actively evolving through the v2 Beta phase, with the latest releases such as 2.0.0-beta.19 indicating rapid iteration. This phase represents a complete architectural overhaul from the original v1 codebase to a rewritten Electron-React-TypeScript stack.

Key characteristics of the current beta include:

• Electron 43 provides the native window and system integration, as documented in the README architecture overview【/cache/repos/github.com/agalwood/Motrix/main/README.md#L38-L40】.
• React 19 combined with Tailwind CSS 4 and shadcn/ui powers the renderer interface.
• The UI layer is strictly separated from the core logic to ensure future engine swaps do not disrupt the user experience.

Path to Stable v2

The roadmap targets a Stable v2 release once the API is frozen and all release gates are passed. This milestone will deliver production-ready packages for macOS, Windows, and Linux, alongside a stable headless server runtime.

The README already references stable packaging commands in the Installation and Build sections, indicating the infrastructure is prepared for the transition out of beta【/cache/repos/github.com/agalwood/Motrix/main/README.md#L80-L90】.

Planned Rust Engine Rewrite

A critical future milestone on the development roadmap is the Rust Rewrite of the download engine. According to the architecture diagram in the README, the codebase "keeps a clear path for a future Rust rewrite"【/cache/repos/github.com/agalwood/Motrix/main/README.md#L50-L60】.

This initiative aims to replace the current JavaScript-based download engine (an aria2 fork) with a Rust implementation to improve performance and safety. The Engine Adapter layer in src/core/** connects the core to the bundled aria2 fork and is designed to allow this swap without modifications to the UI or plugin systems.

Plugin Ecosystem Expansion

The roadmap prioritizes growing the Plugin Ecosystem through the official Plugin SDK repository (@motrix/plugin-sdk). Current development focuses on:

• Expanding the Builtin Plugins catalog.
• Improving the QuickJS sandbox environment (QuickJS-emscripten) that runs plugins in isolation.
• Building out the official plugin marketplace infrastructure.

These components are listed as core elements of the ecosystem in the repository documentation【/cache/repos/github.com/agalwood/Motrix/main/README.md#L80-L90】.

Cross-Platform Enhancements

Ongoing work includes refinements for platform-specific features and distribution methods. The README describes active development on:

• macOS menu preview functionality.
• Finalized Snap/Flatpak publishing pipelines.
• Improved Docker server deployment integrations.

The Docker server deployment guide in docs/docker-server.md indicates this is a maintained priority for headless server use cases.

Key Source Files and Architecture

Understanding the following directory structure is essential for contributors tracking the roadmap implementation:

Path	Purpose
src/renderer/**	React UI components (dashboard, settings, downloads).
src/main/**	Electron main process handling IPC, native menus, and platform-specific code.
src/core/**	Core task management, settings, and plugin logic shared between desktop and server runtimes.
packages/native-host/**	Native host binary (the aria2 fork) and associated build scripts.

These layers are deliberately decoupled so the future Rust rewrite can replace the engine adapter without touching the UI or plugin system.

Working with the Current Codebase

Developers and power users can engage with the current beta using these established workflows:

Install the CLI client

# Requires Node 22+

npm install -g @motrix/cli

Add a download from the command line

motrix add https://example.com/file.iso --save-dir ~/Downloads

Run Motrix in development mode

git clone https://github.com/agalwood/Motrix.git
cd Motrix
pnpm install          # Pulls aria2 binary and rebuilds native modules

pnpm start            # Launches Electron with Vite HMR

Scaffold a new plugin

pnpm create motrix-plugin my-plugin
cd my-plugin && pnpm install
pnpm dev              # Watches, builds, and launches Motrix with plugin loaded

Deploy the headless server with Docker

docker compose pull server
docker compose up -d --wait

Summary

• The v2 Beta is actively progressing through releases like 2.0.0-beta.19, featuring a complete Electron-React-TypeScript rewrite.
• Stable v2 will freeze the API and ship production packages for all major platforms once beta testing concludes.
• A Rust engine rewrite is architecturally planned to replace the JavaScript-based aria2 fork for improved performance.
• The plugin ecosystem is expanding through the Plugin SDK and QuickJS sandbox environment.
• Cross-platform support is being refined for macOS, Linux (Snap/Flatpak), and Docker server deployments.

Frequently Asked Questions

When will Motrix v2 reach stable release?

Motrix v2 will transition from beta to stable once the API is frozen and all release gates are passed. The current beta program (at 2.0.0-beta.19) is ongoing, with stable packaging instructions already documented in the README for the upcoming release.

Will the planned Rust rewrite affect existing plugins?

No, the Rust rewrite is designed to be transparent to plugins. The architecture separates the Engine Adapter (which connects to the download engine) from the Plugin Sandbox and UI layers. This modularity ensures plugins running in the QuickJS environment will continue to function without modification when the Rust core replaces the current aria2 fork.

How can I test the latest beta version?

You can build from source using git clone and pnpm install, or download pre-release binaries from the GitHub releases page. The development workflow supports hot module replacement (HMR) via Vite when running pnpm start, allowing you to test changes to the React renderer in real time.

What runtime powers the headless Motrix server?

The headless server runs on Node.js with Fastify and WebSocket support, making it suitable for Docker deployment. As documented in docs/docker-server.md, you can deploy the server using docker compose up, which provides a web-based interface for managing downloads without the Electron desktop application.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}