gawdl3y / resolute

Mod Manager GUI for Resonite

Resolute

Mod Manager GUI for Resonite

Resolute is a friendly GUI application for installing, updating, and managing Resonite mods. The goal is to provide a cross-platform beginning-to-end setup experience for Resonite modding.

Resolute loads its mod index and metadata from the Resonite Mod Manifest.

Important

Resolute is built with Tauri, which relies upon your operating system's WebView to function. If you're on Windows and have completely removed WebView2 and Edge from your system, Resolute will not work. If you remove Edge but leave WebView2 intact, it should work fine.

Features

Implemented

• Manifest handling
  • Downloading
  • Caching
  • Parsing
• Mod management
  • Listing (installed and all available)
  • Installation
  • Updating
  • Deletion
  • Detection of externally-installed mods
• Mod authoring tools
  • SHA-256 checksum calculator
• Automatic app updates

Planned

• Mod disabling/reenabling
• Drop mod file to install
• ResoniteModLoader/Harmony alerts (missing or outdated)
• Deprecated mod/mismatched platform alerts
• Dependency resolution
  • Automatic installation
  • Conflict warnings
• CLI

Downloads

All release builds are available in the Releases section, but below are some quick links for the most common ones from the latest release (v0.8.3).

• Windows installer (exe)
• Linux AppImage (Universal)
• Linux RPM (Fedora, RHEL, etc.)
• Linux DEB (Debian, Ubuntu, etc.)

Contributing

All contributions are welcome! Try to keep PRs relatively small in scope (single feature/fix/refactor at a time) and word your commits descriptively.

The project is built with Tauri, which is similar to Electron but faster and much more lightweight. It uses Rust for the backend application code and HTML/JS/CSS via the user's operating system's WebView for the frontend. Specifically, Resolute's frontend is a Vue single-page application using Vuetify as its UI framework.

The library code in crates/resolute is externally reusable by other projects and thus is versioned separately. Most new features on the backend are developed there first, with the application code in crates/tauri-app simply calling those library functions.

Resolute uses ESLint + Prettier for HTML/JS (frontend) linting/style enforcement and Clippy + rustfmt for Rust (backend) linting/style enforcement.

Directory breakdown

• crates/resolute: Main Resolute library code where most business logic lives
• crates/tauri-app: Tauri application code (the backend of the app)
• ui: Frontend UI code

License

Most of the project is licensed under the GPLv3 license.
The library code located in crates/resolute is instead licensed under the LGPLv3 license.

resolute's Issues

Console log in users local timezone

It is currently 8:10pm on 4/16 but looking at this log it is a bit odd to know the time these occurred as they are all set as UTC 0 instead of being shown in my timezone.

Just a small enhancement to consider.

Notifications system

The app should have a method to display notifications temporarily on-screen before they then go into a separate notifications list.
Any existing message boxes should be updated to use this system:

• Mod installed
• Mod failed to install

Mismatched dependency and conflict warnings

Resolute should display warnings whenever mods are installed/active that have unresolved dependencies or conflicts with other mods.

Shortcuts to open relevant directories in OS file explorer

There should be buttons/links to open important directories in the OS file explorer. Examples of such directories:

• Resonite path
• Resonite logs path
• Resonite cache path
• Resonite DB path
• RML mods path
• RML libs path
• RML config path

Add Expand All and Collapse All buttons to the Mod Index page

It is annoying needing to click each arrow manually to expand the categories

Detect externally-installed mods

The app should have a mechanism to detect mods that were manually installed or installed by Resolute before #12 was implemented.

Blocked by #12.

Console/log viewer in the UI

The app should have a page to view all internal logging output of the current execution in a convenient way within the UI.
This is friendlier to the average user than a log file, but also generally more convenient to quickly check what happened behind the scenes for an action.

Make tags searchable/filterable

Currently, the tags on a mod are not searched against when filtering the mod list. Ideally, these should be taken into account whenever filtering.

Mod details UI

The app should have some kind of UI to present additional mod details, such as the author(s), source location, icon, etc.

Log file

The application should forward all internal logging to a log file (or multiple) in one of its directories.
This will greatly increase the transparency of its operation and allow for much easier debugging of production builds in the future.

Unable to install Resolute on Windows with WebView2 and Edge removed

The installation .exe fails installing webview2 when I run it. My assumption is that this is because I've removed Edge via https://github.com/AveYo/fox

I'm assuming WebView is a dependency for the app? If so, it may be a good idea to add that info to the readme, as It's not too uncommon for folk to remove webview and edge together.

Text styles are inconsistent

Text styles are currently used inconsistently throughout the UI - some are unspecified, some headers are used, and the body text classes are mostly unused. Ideally, every bit of text should have a proper text style applied if it isn't already by a Vuetify component.

Custom manifest URL setting

Users should be able to override the manifest URL that gets downloaded and parsed for the mod listing.

Unable to work on Windows 11 due to detected trojan virus

Trojan:Script/Wacatac.B!ml

Verify checksum of downloaded artifacts

When artifacts are downloaded, they should be hashed and verified against the checksum listed in the manifest.

Show app version number

The app's current version number should be displayed somewhere so that it can be easily checked.

Installed mods page

With installed mod state tracking implemented, the UI should have a dedicated Installed mods page that only displays mods that are currently installed. It should still retrieve the latest manifest info for it in order to display the correct latest version information.

Selecting native Linux Resonite directory always shows missing executable warning

When selecting the Resonite directory with a native Linux build of the game, the UI always warns that it wasn't able to find the Resonite executable. This is due to the UI only looking for Resonite.exe, whereas the native Linux build's executable is Resonite.x86_64.

Discover and list installed mods that aren't on the manifest

It would be nice to be able to see these mods even if there would be no update tracking.

Warning on mod lists for installed mods that are deprecated or don't support the current platform

There should be two easily-noticeable warnings present for mods on the mod list:

• When a mod has the "deprecated" flag
• When a mod doesn't list the current platform as one of the supported platforms

Allow recognition of installed mods with different filenames than the manifest specifies

Looks like any file that contains dll is located and listed, notably .dll.old and .dll.disabled. These will add additional 'Unrecognized' entries.

When updating, the .dll.old file will also be picked up and show as another entry, even if the hash matches an existing hash of a known mod
These two entries are for the same mod, one of which is ending in '.dll.old' but they have the same hash

Installing a mod doesn't guarantee the latest version is used

Currently, when installing a mod, the first version entry from the manifest is used. These version entries may not be guaranteed to be sorted in descending order, which means installing a mod may end up using an old version.
The newest version should always be installed by default. This can be achieved by sorting the versions (either before handing them to the UI or done within the UI layer) upon loading them.

Command-line interface for major functions

In order to accommodate for scripting/automation, the major functions (installing/uninstalling/updating/listing mods) should be available via a CLI in the app.

Automatic dependency installation

When installing a mod, if the version has any dependencies, Resolute should offer to install those automatically alongside the original mod being installed.

Standalone exe download

I think there should be a standalone exe download, as I like to put the resonite folder to have everything in one place

Auto-detect possible Resonite installation directory

The app should offer a way for it to auto-detect possible Resonite installation paths and should automatically run this procedure on startup when the setting is unset. The main focus for now should be locating a Steam installation and going off of that, as Resonite doesn't currently have any official standalone releases. It's also probably not worth trying to locate secondary Steam libraries.

Known details:

• Windows:
  • Usually %programfiles(x86)%\Steam
  • Can be detected from the registry (HKCU\Software\Valve\Steam\SteamPath)
• Linux
  • Traditional: ~/.steam/steam/
  • Flatpak:
    • Usually ~/.var/app/com.valvesoftware.Steam/.local/share/Steam
    • Can be detected via flatpak info --show-location com.valvesoftware.Steam and ascending two directories from the returned path

Once a Steam installation is located, the game's installation folder can be extra confirmed by checking for and reading Resonite's ACF (should be $STEAM/steamapps/common/appmanifest_2519830.acf), though this is likely unnecessary.
It's probably safe to assume that the path is always going to be $STEAM/steamapps/common/Resonite.

Track and indicate mod installation status

The app should track what mods it has installed and show indication that they are installed, as well as which version is installed.

Use steamlocate crate instead of looking for Steam manually

there is a crate called steamloacte (https://crates.io/crates/steamlocate/) which can easily find steam library folders, and even a specific app like resonite, though this library has some known bugs in it's current latest release and I'd probably wait until they release 2.0.0 (which they probably will soon, considering there is already a beta version)

Out-of-the-box (OOB) setup introduction flow

On first launch (and maybe upon demand with a button hidden away somewhere), an introduction and setup guide experience should be presented to the user. This should walk the user through:

• Installing RML
• Installing Harmony
• Setting the Steam launch parameter (-LoadAssembly Libraries/ResoniteModLoader.dll)

Windows portable EXE builds

I don't need an installer for a single self-contained exe file

Add UserAgent to web requests

Currently web requests have no UserAgent. Tested with the custom manifest url.

Mod disabling & reenabling

Once a mod is installed, the user should be able to toggle whether it is enabled or disabled without fully uninstalling it.

Blocked by #12

Warning when Resonite directory isn't configured or doesn't exist

A warning should be displayed whenever the Resonite directory isn't configured or doesn't seem to exist on the filesystem.

Additional UI feedback/indication for long-running actions

The UI should display loading indicators and have relevant success/failure notifications for the following:

• Clicking an install button (needs loading indicator)
• Clicking the refresh button (needs loading indicator and failure notification)
• Manifest loading on startup (needs failure indication)

Detection and display of non-manifest mods

Ideally, the app should be able to detect and display mods that artifacts are present for that aren't in the manifest.

Allow configuration of the HTTP connection timeout

As title, environments with unstable connections are entirely unable to download mods with Resolute.
Due to a temporary situation, my average latency times are quite high, and Resolute seems to not like that, as I get timeout errors as the image below.

it is to note that regular downloads of the files via browsers, download managers and such are possible.

Latency test to nearest CF edge of my connection for reference

I'm aware that this is most likely not a priority, but a more robust download system would definitely be of benefit. Or at least a way to set a manual timeout value that is not as strict.

Searching and filtering of mods

The mod list table should be both searchable and filterable by columns.

Error occurring during update results in dialog being stuck open and loading

When an update is found and the user chooses to install it in the dialog, if an error is encountered during the update installation, the dialog gets stuck open in a loading state perpetually.

Default pagination behaviour is unintuitive with the grouped mod list

As title mentions the all mods list scroll bar doesn't reach the bottom when more than a couple categories are expanded

Log setting changes

Changes to settings should be logged as they are saved.

Custom update dialog

The app should have its own custom update dialog rather than using the default Tauri one.
This will allow proper display of the markdown changelogs.

Mod uninstallation

Users should be able to uninstall a mod after they have installed it.

Blocked by #12

Improvements to fuzzy searching/filters

Being able to search the contents of name + tag/description/etc in the same query separated by spaces would be beneficial especially as partial matches. I'm not sure how much partial matching it currently allows as it seems to include spaces in the search

Searching for "No " should still find NoTankControls but doesn't as the mod name doesn't have a space and the description doesn't include it either.

Localization/internationalization

The app should support multiple languages, especially given the diverse community that Resonite serves as home to.

Error messages from external crates on the backend are out-of-scope, as that would be nearly impossible to achieve with any consistency.

Error messages from Resolute's own code in the backend are doable since nearly all errors are already their own type and thus can be sent to the frontend via error codes rather than raw strings.

Provide download links in readme

Currently some users, especially those less versed in github or other types of programs/executables are experiencing confusion when trying to find the download for the program. Ideally a simplified list of 2-3 options on the readme to link for each platform download with additional builds in the release tab as normal. Then people can be presented a small few options instead of 17 things they could download. (Current total count of assets)

Somewhat related to #58

Allow installation of previous versions of mods

The app should allow users to select a specific version of a mod to install in case they don't just want the latest version.

More mod info from DLL files for mods outside of the manifest

I'd love to see the DLL version info be tried to be parsed and be shown similarly as mods from the manifest. Though I'd except the unknown mods to keep the blue question mark to indicate that they aren't actually from the manifest, and the details are just provided by the file metadata :P

I do realize this is most likely a low priority feature request, so I did play around with the idea of making a PR but for now I ran out of time 😅

fn get_assembly_version<P: AsRef<Path>>(path: &P) -> Option<semver::Version> {
	use pelite::FileMap;
	use pelite::pe32::{Pe, PeFile};

    let Some(file_map) = FileMap::open(path).ok() else { return None;};
    let Some(file) = PeFile::from_bytes(file_map.as_ref()).ok() else { return None;};
		let Some(resources) = file.resources().ok() else { return None;};
		let Some(version_info) = resources.version_info().ok() else { return None;};
		let Some(fixed_info) = version_info.fixed() else { return None;};
    Some(semver::Version {
			major: fixed_info.dwFileVersion.Major as u64,
			minor: fixed_info.dwFileVersion.Minor as u64,
			patch: fixed_info.dwFileVersion.Patch as u64,
			pre: Default::default(),
			build: semver::BuildMetadata::new(&fixed_info.dwFileVersion.Build.to_string()).unwrap_or_default(),
		})
}

The ProductName could be gotten in a similar way for the hypothetically correct GUIDs to show.

Show mod author name(s) for each mod listed in the Mod Index page

This could be optional maybe

Setting for app theme & system theme detection

Currently, the app is hard-coded to dark mode.
Users of the app should have a choice between dark mode, light mode, and following their system theme, with following the system theme being the default.

Atomic mod artifact downloads

Mod artifact downloads done by the Resolute library code should be atomic (download to a temporary file then moved/renamed), thus being much less error-prone in the event of networking issues or other problems encountered. Any errors encountered while downloading an artifact should result in no further artifacts being downloaded, any already-downloaded ones deleted, and the user should be alerted to the failure.