Multi-segment parallel downloads, resume, queueing, HLS video capture, and a browser extension — powered by a Rust engine with a Flutter UI.
Features · Screenshots · Download · Build from Source · Browser Extension · Architecture · Roadmap · Contributing
Shinsoku (Japanese 神速, "godspeed") is a fast, free, open-source download manager
for the desktop. It splits every download into many parallel byte-range segments to
saturate your connection, resumes cleanly after interruptions, manages a prioritized
queue, verifies file integrity, and can grab HLS (.m3u8) video streams as a single
file. A companion browser extension hands off downloads — cookies, referrer and
User-Agent included — so logged-in and gated links just work.
The download engine is written in Rust for true thread-level parallelism and
zero-copy streaming I/O; the interface is built once in Flutter for Windows, Android,
and Linux. The two are bridged with type-safe async bindings via
flutter_rust_bridge.
Status: Windows is the primary, actively-developed target. Android and Linux build wiring is in progress — see the roadmap.
- ⚡ Multi-segment parallel downloading — configurable connections (default 8–16) with per-segment byte-range requests to maximize throughput.
- ⏯️ Pause & resume — exact byte-accurate resume using HTTP range requests; survives app restarts.
- 📋 Download queue & priorities — control how many downloads run at once and in what order.
- 🎚️ Bandwidth throttling — global and per-download speed limits.
- 🌙 Off-peak acceleration — automatically lifts the speed cap during a window you define (re-evaluated live, wraps past midnight).
- 🔁 Auto-retry — transient failures are retried automatically.
- 🔐 Integrity verification — streaming SHA-256 / MD5 check after completion; paste an expected digest and Shinsoku verifies it (algorithm inferred from digest length).
- 🎬 HLS video capture — parses
.m3u8playlists, picks the highest-bitrate variant, downloads segments with bounded concurrency, AES-128 decrypts, and concatenates to a single.ts/.mp4file (VOD). - 🧩 Browser extension — Chromium (Chrome/Edge/Brave) and Firefox MV3 capture with a token-protected loopback handshake; forwards cookies, referrer and User-Agent.
- 📎 Clipboard monitoring — copy a link and Shinsoku offers to grab it.
- 🗂️ Auto-categorize — sort completed files by type.
- 🔔 Update checker — tells you in-app (sidebar) when a newer GitHub release is available and links straight to it.
- 🖥️ Native desktop polish — system tray, custom frameless window, bundled fonts, dark "voltage" theme.
The main window — live throughput graph, multi-segment progress bars and the active queue.
 Active downloads — live speeds, ETAs & per-segment progress |
 Download detail — segment map, speed chart & integrity check |
 Add a download — URL probe, custom headers & expected hash |
 Settings — connections, throttle, off-peak & browser pairing |
 Completed — finished, categorized download history |
|
 Browser extension — HLS stream detection with one-click send |
 System tray — runs in the background with quick controls |
Just want to use Shinsoku? Grab the latest Windows build — no toolchain required.
➡️ Download the latest release
- Download
Shinsoku-vX.Y.Z-windows-x64.zipfrom the release assets. - Unzip it anywhere and run
shinsoku.exe(portable — no installer yet). - (Optional) Grab
chromium.zip/firefox.zipfrom the same release for the browser extension.
Shinsoku checks the release feed on launch and tells you in the sidebar when a newer version is available, linking straight to the download.
Windows SmartScreen may warn on first run because the build isn't code-signed yet — choose More info → Run anyway. Android and Linux builds are not published yet (see the roadmap).
For developers and power users who want to build, hack on, or run the latest main.
| Tool | Version | Notes |
|---|---|---|
| Flutter SDK | 3.12+ (Dart 3.12) | enable desktop: flutter config --enable-windows-desktop |
| Rust toolchain | stable | rustup recommended |
flutter_rust_bridge_codegen |
2.9.0 | only needed if you change the Rust API: cargo install flutter_rust_bridge_codegen --version 2.9.0 |
| Visual Studio 2022 | — | "Desktop development with C++" workload (Windows builds) |
git clone https://github.com/purukitto/Shinsoku.git
cd Shinsoku/app
# Fetch Dart deps
flutter pub get
# Run the desktop app (release recommended for real performance)
flutter run -d windows --release
# …or produce a distributable build (output: app/build/windows/x64/runner/Release/)
flutter build windows --releaseThe Rust engine in core/ is compiled automatically as part of the Flutter
build via flutter_rust_bridge — you don't build it separately.
If you change the Rust API surface in core/src/api.rs, regenerate the Dart bindings
(run in app/):
flutter_rust_bridge_codegen generate
⚠️ Files underapp/lib/src/rust/andcore/src/frb_generated.rsare auto-generated — don't hand-edit them.
# Rust engine tests
cd core && cargo test
# Flutter analyzer + tests
cd app && flutter analyze && flutter testMaintainers bump versions in lockstep and tag — the release workflow then builds the Windows app + extension and publishes a GitHub Release:
pwsh tool/bump-version.ps1 X.Y.Z # bumps app + core + extension, rolls CHANGELOG
git push && git push --tags # pushing the vX.Y.Z tag triggers the buildShinsoku ships a browser extension (Chromium + Firefox MV3) that intercepts browser downloads and forwards them — with the cookies, referrer and User-Agent the browser would have used — to the running app, so authenticated and referrer-gated downloads work. It also detects HLS video streams and lets you send them to Shinsoku from the toolbar.
It talks to a tiny token-protected loopback HTTP server hosted by the app (no native messaging, no per-browser manifest install) and pairs with a single code.
➡️ Build, install & pairing instructions: extension/README.md
Shinsoku is a monorepo: a Rust engine, a Flutter UI, and a browser extension.
Shinsoku/
├── app/ # Flutter UI — Windows, Android, Linux (single codebase)
│ └── lib/src/
│ ├── rust/ # auto-generated flutter_rust_bridge bindings (do not edit)
│ ├── ui/ # screens & widgets (desktop shell, detail, settings…)
│ ├── providers/ # Riverpod state (downloads, settings, capture)
│ └── services/ # settings, capture, tray
├── core/ # Rust download engine (libshinsoku)
│ └── src/
│ ├── engine/ # multi-segment download, worker, throttle, orchestrator
│ ├── queue/ # queue, scheduler, off-peak manager
│ ├── protocols/ # HTTP/HTTPS + HLS (m3u8)
│ ├── storage/ # partial files, assembly, atomic store, integrity
│ └── capture/ # loopback server for the browser extension
├── extension/ # Chromium + Firefox MV3 capture extension
├── docs/ # screenshots & assets (logo, icon)
└── packages/ # shared Dart/Flutter packages (UI kit)
Design principles
- All download logic lives in Rust. The UI never re-implements engine behavior; it watches narrow state slices through Riverpod so rebuilds stay tight.
- Engine-owned persistence. The download list + history serialize to a single atomic JSON file (temp + rename) written by the Rust core. App settings live in a separate app-side JSON.
- Performance is a first-class requirement — see the perf rules in
CLAUDE.md.
Key architecture decisions (persistence, capture server, integrity, off-peak, HLS) are
recorded under Resolved Decisions in CLAUDE.md.
| Platform | Status |
|---|---|
| Windows | ✅ Primary target — engine + UI wired end-to-end |
| Android | 🚧 Build wiring in progress |
| Linux | 🚧 Planned (Flutter Linux is mature; low incremental cost) |
| macOS / iOS | ❌ Out of scope for now |
| Capability | Status |
|---|---|
| Multi-segment HTTP/HTTPS downloads | ✅ |
| Pause / resume / auto-retry | ✅ |
| Queue, priorities & throttling | ✅ |
| Off-peak acceleration | ✅ |
| Integrity check (SHA-256 / MD5) | ✅ |
| Browser capture (cookies/referrer/UA) | ✅ |
| HLS / m3u8 capture (AES-128, VOD) | ✅ |
| Packaging / installers | 🚧 |
| CI/CD release pipeline | ✅ tag-triggered Windows build + GitHub Release |
| FTP, magnet / torrent | 💡 Future |
| Live HLS / DASH / SAMPLE-AES | 💡 Future |
Legend: ✅ done · 🚧 in progress · 💡 idea / future
| Layer | Choice | Why |
|---|---|---|
| Engine | Rust + tokio + reqwest (rustls) |
true thread parallelism, zero-copy streaming, production HTTP |
| UI | Flutter | one codebase for Windows, Android, Linux |
| Bridge | flutter_rust_bridge v2 |
type-safe async Dart ↔ Rust bindings |
| State | Riverpod | narrow, performant state slices |
| Integrity | sha2, md-5 |
streaming hashing |
| HLS crypto | aes, cbc |
AES-128 segment decryption |
| Capture server | axum |
tiny token-guarded loopback API |
| Persistence | atomic JSON (engine) | no DB dependency; survives restarts |
Contributions are very welcome — bug reports, features, docs and tests!
- Read the Contributing Guide for setup, workflow and code conventions.
- Found a vulnerability? See the Security Policy.
Good first contributions: Android/Linux build wiring, packaging/installers, and code-signing the Windows release.
The browser-capture loopback server binds to 127.0.0.1 and is guarded by a pairing
token. Please report security issues privately — see SECURITY.md.
Shinsoku is licensed under the GNU General Public License v3.0. See LICENSE.
This means you're free to use, study, share and modify it — but derivative works that you distribute must also remain open source under the GPL.
flutter_rust_bridge— the FFI bridge that makes this architecture possible.reqwest,tokio,axumand the broader Rust async ecosystem.- Riverpod for Flutter state management.
- Fonts: Space Grotesk and JetBrains Mono (SIL Open Font License).
Built with ⚡ and Rust. If Shinsoku is useful to you, consider leaving a ⭐.