# Dorion: a small Tauri-based Discord client with themes and plugins

> Dorion is a GPL-3.0 alternative Discord client written in Rust on Tauri, aimed at low-spec and storage-sensitive machines. It ships installers for Windows, macOS, Debian and Fedora, plus plugins and themes, but the README leaves several operational questions unanswered.

**SpikeHD/Dorion** — Tiny alternative Discord client with a smaller footprint, snappier startup, themes, plugins and more!

- Repository: https://github.com/SpikeHD/Dorion
- Website: https://spikehd.dev/projects/dorion/
- Stars: 2,599 · Forks: 74
- Language: Rust
- License: GPL-3.0
- Published: 2026-09-28 · Updated: 2026-09-28 · Language: en
- Canonical page: https://hysenlabs.com/projects/spikehd-dorion

## What Dorion replaces, and for whom

The README describes Dorion as "an alternative Discord client aimed towards lower-spec or storage-sensitive PCs that supports themes, plugins, and more". That sentence is the whole positioning. The target user is not someone unhappy with Discord's feature set; it is someone whose machine struggles with the official client's disk and memory footprint, or who wants to run a Discord front end on hardware where the official build is impractical.

The plugin and theme support matters because it changes what you give up. A stripped-down client normally means fewer customisation options. Dorion keeps a plugin surface, which the repository layout confirms: there is a src-tauri/injection/ directory containing preinject.ts and postinject.ts, and a build:js script that bundles and minifies both into preinject_min.js and postinject_min.js. Injection scripts are how a wrapper client alters the web app it loads. So Dorion is not a reimplementation of the Discord protocol; it is a host that loads Discord's own web client and patches it.

That distinction decides who should care. If you want a client that talks to Discord's API independently, Dorion is not that. If you want a lighter shell around the same web app, with a hook for modifications, it is exactly that.

## How the Tauri shell and injection scripts fit together

Dorion is a Tauri application. The repository has a src-tauri/ directory for the Rust side and a src/ directory for the front end, with vite.config.js and package.json driving the JS build. Tauri uses the operating system's webview rather than bundling a browser engine, which is the mechanism behind the smaller footprint claim. On Windows that means WebView2, on macOS WKWebView, on Linux WebKitGTK. The README does not spell this out, but the dependency list and the src-tauri layout are consistent with it.

The injection pipeline is the interesting part. The build:js script runs vite build, then uses esbuild to bundle src-tauri/injection/postinject.ts and src-tauri/injection/preinject.ts into minified ES6 files placed inside src-tauri/injection/. Pre-injection runs before Discord's page code; post-injection runs after. Plugins and themes hook into that pipeline.

There is also a shupdate script that curls shelter.js from the uwu/shelter-builds repository into src-tauri/injection/shelter.js. Shelter is a client mod loader. Its presence in the build scripts tells you Dorion's plugin system is not written from scratch; it leans on an existing modding layer. The README does not document how shelter.js is versioned or when it is refreshed, which is a gap if you plan to track upstream plugin compatibility.

## Installing Dorion from a release asset

The README's download table points at GitHub release assets for v6.13.2. Windows users get an MSI or an NSIS setup executable, macOS users get a DMG, and Linux users get .deb packages for Debian and .rpm packages for Fedora. Each platform lists x86_64 and ARM variants.

On Debian or a derivative, the .deb asset installs with dpkg. Substitute the exact filename from the release page, since the README's link text is the architecture label rather than the filename:

```bash
wget https://github.com/SpikeHD/dorion/releases/download/v6.13.2/Dorion_6.13.2_amd64.deb
sudo dpkg -i Dorion_6.13.2_amd64.deb
```

After installation the binary should be on your PATH as Dorion, and the desktop entry should appear in your application menu.

The README also states that Dorion "can also be used portably or installed via several package managers", and that portable builds live on the releases page. It links a Package Repositories section, but the cleaned README does not show which repositories those are, so treat the package-manager route as something to verify on the project page rather than something you can copy from the README.

macOS users hitting the unidentified developer warning are given a specific remedy:

```bash
sudo xattr -rd com.apple.quarantine /Applications/Dorion.app
```

The README presents this as an alternative to opening Privacy & Security and removing the quarantine through the Security section. Windows users are warned that Defender may flag Dorion, and that SmartScreen can be bypassed through More Info and Run Anyways.

## Building from source, and what the scripts assume

The README has a Building section with Prerequisites and Steps, but the cleaned text does not include their contents, so the reliable source is package.json. It declares pnpm@12.4.1 as the package manager, and the scripts assume a working Rust toolchain plus the Tauri CLI, which is listed as a devDependency at @tauri-apps/cli.

The development entry point is:

```bash
pnpm install
pnpm dev
```

The dev script is defined as pnpm build:js && tauri dev, so it rebuilds the injection bundles before starting Tauri. If you edit anything under src-tauri/injection/, you need that rebuild step; running tauri dev directly will not pick up your changes.

There is a separate updater crate. build:updater changes into updater/, runs cargo build --release, then copies the resulting binary to src-tauri/updater. That means the update mechanism is a compiled Rust binary shipped alongside the app, not a script. The README does not describe how that updater decides what to fetch or how it verifies a download.

Formatting and linting are split across two crates. pnpm codefix:all runs cargo fmt, prettier, cargo clippy with --no-default-features and -D warnings, and eslint over src-tauri/injection/**/*.ts. If you intend to send a patch, that is the gate it has to pass.

## Where Dorion is the wrong tool

The README's own notes are the clearest limitation. Windows Defender may classify Dorion as a virus, and the README's advice is to click through SmartScreen. macOS blocks the app as from an unidentified developer until you strip the quarantine attribute. Neither is a bug in Dorion's logic, but both mean the install path depends on the user overriding a security prompt. On a managed corporate machine, that may be impossible, and Dorion is then simply not deployable.

The second limitation is documentation coverage. The README has a Known Issues section and a Troubleshooting section with subsections for General, Windows and Linux, but the cleaned text does not show what is in them. There is no documented rollback for a plugin that breaks the client, no stated compatibility matrix for shelter.js versions, and no description of how the updater validates what it downloads. If your tolerance for undocumented failure modes is low, that matters more than the footprint savings.

The third is structural. Because Dorion wraps Discord's web client and injects into it, it is exposed to whatever Discord changes in that client. A protocol-level reimplementation would be insulated from front-end changes; an injection-based client is not. The README does not claim otherwise, but it is worth being explicit about the trade you are making.

## Dorion compared with a plugin-free wrapper

The natural alternative is a minimal wrapper that loads Discord's web client in a system webview with no injection layer at all. That approach gives you the footprint reduction, which is Dorion's headline claim, without the plugin and theme machinery.

The difference is not cosmetic. Without preinject and postinject scripts, there is no build step that has to keep pace with the web client, no shelter.js dependency pulled from a third-party repository, and no chance that a plugin update breaks startup. You also lose every reason to pick Dorion over a plain wrapper: themes, plugins, and the customisation those enable.

Dorion's bet is that the injection layer is worth its maintenance cost. The repository supports that bet with tooling: eslint is configured for the injection TypeScript, clippy runs with -D warnings, and the build pipeline minifies both injection files on every JS build. That is more process than a hobby wrapper usually carries. Whether it is enough depends on how often shelter.js and Discord's front end change, which the README does not address.

## Licence, packaging and what to check before you commit

Dorion is GPL-3.0. If you fork it, redistribute a modified build, or ship it inside a product, the copyleft terms apply to the combined work, and the LICENSE file at the repository root is the authoritative text. This is not legal advice; if redistribution is part of your plan, read the licence yourself or get counsel.

The repository carries packaging files that tell you the project cares about distribution beyond GitHub releases: a PKGBUILD for Arch-style packaging and a flatpak/ directory for Flatpak. Both are at the top level. The README's Package Repositories section is the place those are supposed to be documented, and the cleaned text does not show its contents.

Upgrade cost is the open question. The updater crate exists and compiles to a binary, but the README does not describe its behaviour. Releases are frequent enough that the project is clearly moving: v6.13.0 in July 2026, v6.13.1 in September, v6.13.2 a day before the last push on 2026-09-21. Frequent releases plus an undocumented updater means you should decide deliberately between the release channel and the bleeding-edge builds the README warns "may not work properly, and they probably contain bugs".

Before adopting, verify three things: the exact release asset name for your architecture, whether a package repository exists for your distribution, and what the Known Issues section currently lists.

## Conclusion

Dorion fits users on low-spec or storage-constrained machines who want themes and plugins and are willing to install from a GitHub release rather than a store. It is the wrong choice if you need a documented rollback path for plugins, a signed installer that clears SmartScreen without a prompt, or a client whose update mechanism is described in the README. Before adopting it, check the releases page for the current asset names on your platform, confirm whether a package repository exists for your distribution, and read the packaging files under flatpak/ and PKGBUILD if you intend to redistribute it.

## FAQ

### What is Dorion?

Dorion is an alternative Discord client built with Tauri and written primarily in Rust, described in its README as aimed towards lower-spec or storage-sensitive PCs. It supports themes and plugins and is licensed GPL-3.0.

### How is Dorion different from the official Discord client?

The README positions Dorion as a smaller-footprint client for lower-spec or storage-sensitive machines, with themes and plugins as additional features. It is a Tauri app, so it uses the system webview rather than bundling a browser engine, and it loads Discord's web client through preinject and postinject scripts.

### What alternatives to Dorion exist?

The README does not name any alternatives. The closest structural comparison is a minimal wrapper that loads Discord's web client in a system webview without an injection layer, which keeps the footprint reduction but drops themes and plugins.

## Sources

- [License: GPL-3.0](https://github.com/SpikeHD/Dorion/blob/main/LICENSE)
- [Project website](https://spikehd.dev/projects/dorion/)
- [README](https://github.com/SpikeHD/Dorion/blob/main/README.md)
- [Releases](https://github.com/SpikeHD/Dorion/releases)
- [SpikeHD/Dorion on GitHub](https://github.com/SpikeHD/Dorion)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/spikehd-dorion