# Helios Launcher handles Java and asset setup for modded Minecraft servers

> Helios Launcher is an Electron and Node.js launcher for modded Minecraft that installs the right Java runtime, validates game files before launch, and manages multiple accounts. It is MIT licensed and still in active use, though its tagged releases have not moved since 2024.

**dscalzi/HeliosLauncher** — ☀ Custom launcher for modded minecraft written in Electron and Node.js

- Repository: https://github.com/dscalzi/HeliosLauncher
- Stars: 1,031 · Forks: 2,083
- Language: JavaScript
- License: MIT
- Published: 2026-10-19 · Updated: 2026-10-19 · Language: en
- Canonical page: https://hysenlabs.com/projects/dscalzi-helioslauncher

## The launcher exists to remove Java and file setup from the player's hands

Helios Launcher describes its purpose in one line: join modded servers without worrying about installing Java, Forge, or other mods, and it will handle that for you. The project, formerly called Electron Launcher, is written in Electron and Node.js, with JavaScript as the primary language, and it is published under the MIT licence.

The feature list reads like a list of things that normally go wrong when a new player joins a modded server. There is full account management, with multiple accounts and easy switching, and both Microsoft OAuth 2.0 and Mojang Yggdrasil authentication are supported. Credentials are never stored and transmitted directly to Mojang, which is a specific architectural choice rather than a vague promise. There is a news feed built into the launcher, a settings screen with a Java control panel, a view of the player count for the selected server, and a display of Mojang's service status.

The launcher also updates itself, and files are validated before launch so corrupt or incorrect files are redownloaded rather than causing a broken start. The audience is narrow but clear: players who have been handed a server address and a mod pack, and server operators who would rather their players not touch their Java setup at all.

## Java is installed for you, and you do not need Java at all

Automatic Java validation is the feature that most distinguishes this launcher from a plain game launcher. If the machine has an incompatible Java version, the launcher installs the right one. The documentation is blunt about the consequence: you do not need to have Java installed to run the launcher.

That matters for a server operator handing the launcher to dozens of players with mixed operating systems and stale JDKs. The alternative is a support queue about incompatible Java versions, and the Java control panel in the settings gives a way to see and change what gets used.

The account model has a second useful property. Since both Microsoft OAuth 2.0 and Mojang Yggdrasil flows are handled, a player can bring a Microsoft account or an older Mojang account, and the launcher states that credentials are never stored and transmitted directly to Mojang. Microsoft authentication setup is documented separately in docs/MicrosoftAuth.md, so the OAuth path is treated as a configurable integration rather than a hardcoded flow.

## Installers are per platform, and macOS builds do not cross-compile

Downloads come from the Releases tab on GitHub, with a separate installer for each supported system. The file naming is explicit, which makes picking the right one straightforward: Windows x64 uses Helios-Launcher-setup-VERSION.exe, macOS x64 uses Helios-Launcher-setup-VERSION-x64.dmg, macOS arm64 uses Helios-Launcher-setup-VERSION-arm64.dmg, and Linux x64 uses Helios-Launcher-setup-VERSION.AppImage.

The separator between stable and pre-release builds is done with different links on the releases page, one pointing at the latest release and one at the pre-release list. The project states that the feature list is not exhaustive and invites you to install it to judge what it does.

One constraint is called out during development and applies to the build pipeline rather than to end users: builds for macOS may not work on Windows or Linux and the reverse also holds. If you are producing macOS artifacts, building on Windows or Linux may not work, which matters for anyone who wants to run their own fork.

## Node.js 22 and npm run the development loop

The development setup is documented in enough detail to be reproducible, which is worth noting for a project with this many platform targets. The system requirement is Node.js v22, and the package.json engines field pins it to 22.x.x. The repository also carries an .nvmrc file.

Clone, install and run:

```bash
> git clone https://github.com/dscalzi/HeliosLauncher.git
> cd HeliosLauncher
> npm install
```

Then launch the application:

```bash
> npm start
```

The start script runs electron ., and the build scripts are electron-builder based. Building for the current platform is npm run dist, and the per-platform targets are npm run dist:win, npm run dist:mac and npm run dist:linux, each of which passes a flag through to the same electron-builder build.

```bash
> npm run dist:linux
```

Linting is wired up as an npm script running eslint, with the config in eslint.config.mjs. The main entry point is index.js, and the app source sits under app/ with additional code in libraries/ and build/.

## Debugging needs two configurations because Electron runs two processes

The project asks that all development happen in Visual Studio Code and provides a launch.json with two entries, one for the main process and one for the renderer. The main process entry launches Node against the Electron CLI in the workspace, and the renderer entry launches Chrome type with the Electron binary, passing a remote debugging port.

```json
{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Debug Main Process",
      "type": "node",
      "request": "launch",
      "cwd": "${workspaceFolder}",
      "program": "${workspaceFolder}/node_modules/electron/cli.js",
      "args" : ["."],
      "outputCapture": "std"
    },
    {
      "name": "Debug Renderer Process",
      "type": "chrome",
      "request": "launch",
      "runtimeExecutable": "${workspaceFolder}/node_modules/.bin/electron",
      "runtimeArgs": [
        "${workspaceFolder}/.",
        "--remote-debugging-port=9222"
      ],
      "webRoot": "${workspaceFolder}"
    }
  ]
}
```

Two limits are stated plainly. The renderer configuration needs the Debugger for Chrome extension, and the DevTools window cannot be opened while that configuration is active, because Chromium allows only one debugger and a second one crashes the program. Scripts in the renderer can be debugged from the DevTools window in the other configuration, so the two modes are alternatives rather than something to run at once.

The dependencies explain the runtime shape. helios-core at about 2.3.0 carries the launcher logic, electron-updater handles self-updates, ejs and ejs-electron render templates, got and adm-zip handle network and archive work, toml and semver parse configuration, and @electron/remote is present, which bridges the renderer to the main process.

## The console is a power tool that can leak your own secrets

The launcher exposes a developer console on a keybind:

```bash
ctrl + shift + i
```

The console tab must be selected, and the documentation carries an explicit warning not to paste anything into it unless you are certain what it will do, because pasting the wrong thing can expose sensitive information. That is a reasonable thing for a launcher with account credentials and server configuration to say, and it is more honest than leaving the console undocumented.

Output can be exported by right-clicking anywhere in the console and choosing Save as, which is the supported path for attaching a log to a bug report. The project also points to a wiki for help and a Discord server as the main channel for reaching the developers.

The desktop window also shows the status of Mojang's services and a player count for the selected server, and it can switch between server configurations. Those are small touches, but they are the details that make a launcher usable for a player who has several servers to hop between.

## Releases stopped in 2024 while commits continued, and the licence has a wrinkle

The maintenance picture needs reading carefully. The repository is not archived, and the last push was on 2026-05-04, so work has continued in the repository. The tagged releases tell a different story: v2.2.1 on 2024-03-07, titled an installer security fix, v2.2.0 on 2024-02-22 with Node.js 20 and additional localization, and v2.1.1 on 2024-01-05 which removed the Mojang auth server status. The package.json version is still 2.2.1, matching the newest tag.

The gap between the last push and the last release is the thing to note. Anyone picking a version should read the release notes for v2.2.1 first, since it is a security fix to the installer, and the current code in master may sit well past the newest published build.

Licensing has a wrinkle worth flagging without giving legal advice. The project is distributed under the MIT licence, and the repository root carries a LICENSE.txt file. The package.json, however, declares the license field as UNLICENSED and marks the package private, which is normal for an application that is not published to a registry. The project's own terms for third-party use are short: give credit to the original author and provide a link to the original source, and the documentation describes it as free software while asking for at least that much. A v2 rewrite branch exists but is marked inactive.

## Conclusion

Helios Launcher fits someone who plays on a specific modded server and wants the launcher to own Java installation, file validation and account switching, and it fits a server operator who wants a branded launcher rather than a client that has to be configured by hand. It does not fit a developer who wants to publish a general purpose launcher, since the package is marked private and the project asks third parties to credit the original author instead. Before adopting it, read the v2.2.1 installer security fix notes, check that the platform you need has an installer in the Releases tab, and confirm that a Node.js 22 toolchain is available to you if you intend to build it from source.

## FAQ

### What is Helios Launcher and who is it for?

Helios Launcher is a custom launcher for modded Minecraft written in Electron and Node.js. It is aimed at players who join modded servers and at server operators who want their players to join without installing Java, Forge or mods themselves.

### Do I need Java installed to use Helios Launcher?

No. The launcher performs automatic Java validation and installs the correct version for you if the machine has an incompatible one, and there is a Java control panel in the settings for managing this.

### How do I install Helios Launcher on my system?

Download the installer for your platform from the GitHub Releases tab: an .exe for Windows x64, a .dmg for macOS x64 or arm64, and an .AppImage for Linux x64. The project also publishes pre-release builds on the same page.

### How do I build Helios Launcher from source?

You need Node.js v22. Clone the repository, run npm install, then npm start to launch the application or npm run dist to build an installer for your platform, with dist:win, dist:mac and dist:linux available for specific targets.

## Sources

- [dscalzi/HeliosLauncher on GitHub](https://github.com/dscalzi/HeliosLauncher)
- [Issues](https://github.com/dscalzi/HeliosLauncher/issues)
- [License: MIT](https://github.com/dscalzi/HeliosLauncher/blob/master/LICENSE)
- [README](https://github.com/dscalzi/HeliosLauncher/blob/master/README.md)
- [Releases](https://github.com/dscalzi/HeliosLauncher/releases)

---

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