Arroxy wraps yt-dlp in an Electron app with a browser built in

Most downloaders are a URL box, this one ships a browser

Arroxy is a free open-source desktop GUI that downloads videos, audio, playlists and subtitles from YouTube and 2000+ other yt-dlp supported sites, and the README spends its opening argument on exactly one design decision. It says that most free YouTube downloaders are thin yt-dlp wrappers: a URL box and a format menu, with no browser of their own, and that Arroxy has one, the Explore tab.

That framing matters because the wrapper approach and the browser approach fail in different places. A URL box asks you to paste a link and pick a format, which means the app never visits the page, so it never sees what a signed-in viewer would see, and it never receives the tokens a page loads before a download. Arroxy inverts that. You browse the site inside the app, and the Download button acts on the page you are on, including a playlist or a channel.

The README also states plainly what the project is not trying to be, with no ads, no bloat and no upsells, and the project's home is at orionus.dev/arroxy. The licence is GPLv3, and the copyright and third-party notice files are in the repository root.

Signing in once in Explore, with no cookie export

The Explore tab is where the interesting behaviour lives. The README says you sign in once in Explore, and Arroxy then downloads private, members-only and age-restricted videos your account can watch, plus your Watch Later and Liked lists, with no cookie export. Sign in to other sites there too, and their downloads use that sign-in when they need it.

Two further behaviours are described. Arroxy retries with that sign-in when YouTube asks you to confirm you are not a bot, and its built-in browser gets the token YouTube expects before a download, so YouTube does not cut the download down to fewer formats. The README's judgement on that is blunt: a URL-box wrapper hits all of these limits.

There is a cost to this, and the project is upfront about it. The Explore first-run screen recommends a secondary account as the safer sign-in, because the session you create is stored in the application profile on your machine. Anyone with access to that profile has your signed-in session, and a subscription account is worth keeping out of it. That is a design trade the README documents rather than hides.

Three desktop platforms, several package managers

Arroxy runs locally on Windows 10/11, macOS 13+ on both Intel and Apple Silicon, and Linux, where the README lists AppImage, Flatpak and tar.gz builds. The distribution story is unusually wide for a project of this size: Winget, Scoop through the project's own bucket, Homebrew Cask, Flatpak, AppImage, and a direct download.

The README's table of contents also lists first-launch sections for each platform, a section explaining why you may see a warning, and a section on verifying your download with SHA256. The verification step is the one to use. A downloader distributed through six channels is exactly the shape of project where checking the hash of what you fetched is cheap insurance, and the project has documented the step rather than leaving it to you.

The website, orionus.dev/arroxy, and the releases page are linked from the header badges, and the README records itself as last updated on 2026-10-20.

Formats, trimming, playlists and SponsorBlock

The capability list is broad. The README advertises downloads up to 8K HDR at 60 fps as MP3, AAC or Opus, or just the part you need, and the feature list covers playlists, Shorts, channels, MP3, subtitles and SponsorBlock. Audio tracks and podcasts are named in the opening paragraph alongside video.

The part of a video feature is the most interesting piece of interaction. The screenshot description in the README describes a range bar with start and end times, chapter chips and an exact-cut option, and the text says you pick a start and end, or a chapter, and Arroxy saves only that range. That is a trimming workflow embedded in the downloader rather than something you post-process.

The Downloads tab has a similar conversational shape. Its screenshot description mentions a link preparing in the background, a failed link offering its fix, and a playlist waiting for your choice. In other words, the app queues work, reports failure with the remedy attached, and asks before committing to a long playlist.

One smaller detail worth knowing: the repository carries 31 README translations, from Afaan Oromoo through Amharic and Arabic to Korean and Japanese, so the documentation itself is a maintained surface of the project.

An Electron shell with bun workspaces and vite

The project metadata shows how the application is put together:

{
	"name": "arroxy",
	"version": "0.7.0",
	"private": true,
	"description": "Arroxy - YouTube downloader app",
	"license": "GPL-3.0-or-later",
	"author": {
		"name": "Antonio Orionus",
		"email": "[email protected]",
		"url": "https://x.com/OrionusAI"
	},
	"workspaces": [
		"packages/*"
	],
	"type": "module",
	"main": "out/main/index.js",

It is an Electron application: the entry point is `out/main/index.js`, the build is configured in `electron.vite.config.ts`, and packaging is configured in `electron-builder.json5`. The package is marked private, so it is not published to a public npm registry, and it declares bun workspaces over `packages/*`, with `bun.lock` and `bunfig.toml` for the dependency side. There is a `.node-version` file, and a `flatpak/` directory for the Linux package format, plus `components.json` for component metadata.

Note the version gap. The metadata says 0.7.0 while the newest tags are v0.6.2, v0.6.1 and v0.6.0, all from October 2026. Development on the main branch has moved past the last tag, so a checkout and a release are not the same thing.

Developer scripts for a broken environment

The `scripts` block in package.json is unusually revealing about how the project handles the pain points of Electron development:

		"bootstrap": "bun scripts/dev-env.ts bootstrap",
		"internal:save": "bun scripts/internal-docs.ts save",
		"internal:sync": "bun scripts/internal-docs.ts link",
		"repair": "bun scripts/dev-env.ts repair",
		"doctor": "bun scripts/dev-env.ts doctor",
		"doctor:json": "bun scripts/dev-env.ts doctor --json",
		"dev": "bun scripts/dev-env.ts run electron",
		"dev:gpu": "bun scripts/dev-env.ts run electron --gpu=force",
		"dev:swiftshader": "bun scripts/dev-env.ts run electron --gpu=swiftshader",
		"dev:sandbox": "bun scripts/dev-env.ts run electron --sandbox",
		"dev:fresh": "bun scripts/dev-env.ts run electron --fresh",
		"dev:anon": "bun scripts/dev-env.ts run electron --anon",
		"dev:mock": "bun scripts/dev-env.ts run mock",

`doctor` and `repair` exist because Electron installs break in known ways, and there is a JSON variant for machine-readable output. The dev variants cover the recurring headaches: forcing the GPU, falling back to swiftshader for software rendering, running with the sandbox on or off, starting from a fresh profile, running anonymously, and running against a mock.

The GPU probes go further, with a `gpu:probe` script and modes for force, sandbox, software and swiftshader, one of them setting `ELECTRON_DISABLE_SANDBOX=1` in the environment.

The repository also carries a working-notes layer: `AGENTS.md`, `CLAUDE.md`, a `.agents/` directory, `.coderabbit.yaml`, `DESIGN.md`, `PRODUCT.md`, `GLOSSARY.md`, `DONATE.md`, `TRADEMARKS.md` and `THIRD_PARTY_NOTICES.txt`, plus `CONTRIBUTING.md`, `CHANGELOG.md` and a `dev-docs/` folder. Some of this is documentation for people and some for coding agents, and both are committed.

Where the tool is the wrong choice

Three cases stand out. First, a scripted pipeline. Arroxy is a desktop GUI, and the README is explicit that a URL-box wrapper exists precisely because people want the command line, where a format can be selected by pattern and a directory chosen from the shell. Nothing in the repository describes a scripting interface, so a batch job is better served by yt-dlp itself.

Second, an environment that will not run a bundled browser. The whole design rests on an embedded browser session, and an Electron application brings its own runtime and profile directory, which is awkward on locked-down or minimal systems.

Third, redistribution. The licence is GPL-3.0-or-later, and an Electron app bundles a browser engine, yt-dlp and other components, with the third-party notices file in the repository root. If you intend to redistribute a modified build, that is a question about your own obligations, and the notice file is where the components are listed. This is not legal advice, and the point is simply that a GPLv3 desktop application is a different commitment from running a command line tool you already have.

On the content side, the same caution applies as to any downloader. The README advertises members-only and age-restricted downloads for videos your account can watch, and the legal position on saving a copy varies by content and jurisdiction, which is why the app's own screenshots suggest signing in with a secondary account rather than your main one.

Editorial conclusion

Adopt Arroxy when you want a graphical way to download from the many sites yt-dlp supports, when you need your own signed-in session to reach content your account can already watch, and when you are comfortable with an Electron app holding that session locally. Do not adopt it when you need a scriptable command line pipeline, when your environment forbids bundled browsers, or when GPLv3 redistribution rules do not fit how you intend to ship it. Verify first that `doctor` and `repair` in the developer scripts pass on your machine, that the SHA256 verification step in the README matches the build you downloaded, and that the version you install matches the 0.7.0 in package.json, since the last push was on 2026-10-20 and the newest tags are v0.6.2, v0.6.1 and v0.6.0.

Frequently asked questions

Official sources

1. antonio-orionus/Arroxy on GitHub
2. License: GPL-3.0
3. Project website
4. README
5. Releases