TMM is a Linux native game modding tool. it allows to install and depoly mods for Linux native and wine games.

Last update: Jun 17, 2022

Tux Mod Manager

TMM is a Linux native mod manager made with the Tauri toolkit. It can install, load, remove and deploy mods for both Linux native and WINE games.

TMM Roadmap

  • Move the current mod manager logic to rust
  • Implement a OFS (Overlay File System, similar to VFS from MO2)
  • Make remove button actually work.
  • Add visual indication that a mod is installing
  • Rewrite mod_manager.rs using the steamlocate lib instead of searching for steam directories and games intrusively
  • Only create instance config files if a game is supported
  • Read a game's config from an already existing config file
  • Support storing game files in a user defined directory
  • Download manager for directly downloading mods from websites (e.g. Nexusmods)
    • Front-End Design
    • The actual file download
    • Putting the file in the correct location
    • Input download URL in Front-End
    • Implementing some kind of handshake with the Nexusmods API to allow seamless downlaods via the Mod Manager Download button on their website
    • Displaying the current downloads in the Front-End
    • Improve Downloads Display:
      • Display ETA
      • Download Speed
      • Make Install, Remove and Cancel buttons actually work
  • Move known_path_extensions.json and supported_games.json into tauri's distribution directory, so they are bundled when building the application and aren't required to be in %XDG_CONFIG_DIR%/tmm_stage/
  • Implement a game launcher for native and proton games (for the OFS)
  • Implement a per-game load order
  • Implement mod profiles
  • Create cli commands, example to launch a game from steam with a specifc profile without having to use the mod manager

Current indev issues

  • For games with path extensions, some mods may have the extension folder already in their archive, some may not. This means that sometimes a mod has the extension folder, sometimes it doesn't. In the end this would resoult in the Game not reading some mods, because they're essentially in the wrong folder (e.g. data/data/)
  • Download manager does not yet currently work entirely

Dev environment

If you want to help with the development of Tux Mod Manager you will need to setup a dev environment this is how you do that. (If you would rather just use the software without helping development please wait for a "stable" release)

Install dev environment

git clone https://github.com/MathiewMay/tux-mod-manager
cd ./tux-mod-manager
npm install

Run dev environment

npm run tauri dev

GitHub

https://github.com/MathiewMay/tux-mod-manager
Comments
  • 1. Implemented a WIP Download Manager and reworked the UI for it

    Disclaimer: This is a very WIP feature/overhaul, which is why I marked this as a draft. It is my first major thing built in rust, only my second ever project working with vue and my first time using tauri. If there are any things anybody would like to have changed or advise me about, I very much welcome it, as this is a pretty big opportunity to learn for me.

    Here's a short demo of what I've been working on:

    video

    What I did / am doing here:

    • Rework the UI a bit to be responsive and make the window resizable
    • Implement the ModDownloader, ModManager and ModInstaller in seperate vue sfc files to keep things organized
    • Built a download backend in rust that can do single- and multithreaded downloads and communicate with the frontend based off of https://github.com/mattgathu/duma with modifications and omissions for this project
    • Build support for storing game download and mod files somewhere else than in the user's .config directory based off of game specific config files (which could also be implemented as a single large config file as a collection of all game profiles, not sure about that yet)

    I also added features and planned features to the README on my branch to reflect the changes I'm working on: README.md

    There is no support for Nexus Mod's "Mod Manager Download" yet and I don't know whether it will be easy to implement, but I don't think so, as you need to store user credentials etc. This means the download manager is at best only a commodity right now, but it's a WIP proof of concept.

    Any criticism is also welcome, because - like I said - this is a learning opportunity for me :)

    Reviewed by Erdragh at 2022-06-09 20:28
  • 2. Virtual file system for easy multi-profile management

    This issue refers to this comment on your Reddit post

    Basically, MO2 for windows has the ability to overlay the mod files into the game directory only for the Game and various tools. This is really handy for keeping the game folder clean and not breaking the game with mods. It also enables making easily portable profiles.

    There's OverlayFS and also others as far as I know that should work for Linux.

    Right now this probably won't be a priority, but it'd be something I myself and likely others would like to see as a feature. This would likely also benefit from #2.

    This is just a suggestion and Vortex doesn't implement it, but it's a very big nice-to-have and I have grown used to it with MO2.

    Reviewed by Erdragh at 2022-05-22 10:54
  • 3. More complex deployment of mods.

    The Problem:

    Currently, Tauri moves files into the target folder naively. This can cause issues if and when a file must be overwritten or changed. Furthermore, it can cause issues of duplication, given that the file is now stored at two locations. It also incurs wear on the drive of the user by multiplying writes. Further, it causes the original installation folder to become "tainted" which makes recovery from unstable mods or improperly installed mods difficult.

    The Solution(s):

    • Use Linux's built-in OverlayFS. OverlayFS would behave more-or-less like Mod Organizer's VFS. For a more in-depth explanation of it's functionality, it'd be best to see the Arch Wiki. https://wiki.archlinux.org/title/Overlay_filesystem
    • Link the mods into the game directory and remove the links when done. This allows files to only touch the original folder, rather than actually modify it. Still creates issues with regards to keeping the original files and folders "vanilla"
    • Link the original files to a "staging" folder. This should allow launching the game from the "staging" folder as if that were the original folder, allowing a parallel game install without duplicating files.

    The Why:

    The reason for the alternatives I've suggested is that they're already implemented in any standard, non-archaic Linux system. Anything from the last decade should support these two features. The fact that they're a part of the Linux system also means it doesn't add dependencies. They are also (mostly) non-destructive. They shouldn't touch the original game files directly at all, ideally. The biggest point is to get parity with the likes of Mod Organizer 2 and Vortex. The biggest hurdle, in my opinion, is the implementation of deployment methods that are more complex than just moving files. For some games it may even be necessary to do just that (such as those that require some degree of hackery to get them modding-read). Any further suggestions for deployment methods would be nice. Though I do want to clarify that this issue is not intended to discuss application specific deployment methods, such as may be the case for something like OpenMW where Tauri could edit the OpenMW modding-related configuration files.

    Reviewed by Continous at 2022-05-22 11:11
  • 4. Separate mod manager logic from GUI

    It would greatly benefit from separating the mod manager logic from the GUI itself .

    • easier to read
    • you can more easily rework the UI without having to move a bunch of mod manager logic which can increase the chances of making a mistake
    • you can easily make a cli version ( for launching a game without opening the mod manager GUI for exemple, ... )
    Reviewed by Yato202010 at 2022-05-22 05:01
  • 5. Update supported-games.json

    Added Bethesda Games that just require Mods in the Data folder

    I want to help on the UI as well but I have little experience in vue. But I can Test compatibility for games from both Steam and GOG .

    Reviewed by JDar2K at 2022-06-10 00:24
  • 6. separate mod manager logic from gui

    Added mod_manager.rs and moved scanGames and deployMods to rust instead.

    Deploy will no longer do anything as i will be working on the VFS logic where instead of actually putting the mods into the games folder, it will create a seperate folder for the game and will overlay the mods on top of it, this way the game folder is never actually changed and always stays like it is when downloaded. this will not only make it easier to mod your game but also prevent modding from breaking your game install.

    Reviewed by MathiewMay at 2022-05-24 22:17
  • 7. Overlay fs

    OFS makes it so the mod manager never actually touches your games file, it overlaps all of the mods on top of your games directory as a new mounted directory this way the original directory is never changed.

    Reviewed by MathiewMay at 2022-05-31 22:26
  • 8. Support for game-specific hooks

    I recognise the project is still in early days, but I feel like this would be something useful to consider as development moves forwards.

    To support a wider range of games and the weird and wonderful communities that make up the modding ecosystem, it would be great to have a means of providing some game-specific hooks in the backend code for providing various pieces of functionality.

    (for some background, I maintain Unreal Archive and it's various components and repos - effectively a giant database of Unreal series mods and content - so I'm using this as an example).

    So as someone who'd be keen to contribute some functionality to this project to facilitate the installation and management of the above-mentioned content, the capabilities I'd like to have available include:

    • metadata query:

      • pass in the file/archive the user selected, and either by interrogating the local file content itself (for games which already support this sort of thing natively, or in commonly used mod packaging formats), or calling out to some sort of web service (in my use case, I'd hash the file locally and attempt to lookup metadata from an online source), and return some basic information like: formal name, author, version, release date, web links, etc, which can be displayed in the UI
    • unpacking/installing:

      • in the Unreal example, there's a UMOD format, which is a fairly simple packaging format which a lot of mods were distributed in, intended to provide simple double-click-to-install functionality (Windows only).
      • as such, I'd like the "install mod" functionality to be optionally handed off to some game-specific installer, which again just takes as input the file/archive the user selected, and figures out how to unpack it in whatever game-specific or proprietary format may be required.
        • the unpacked files can be put into some specific directory tree which TMM can then "deploy" using its preferred method (overlayfs, symlinks, copy the files in, etc)
      • this would also go towards unpacking certain mods in certain ways; for example Unreal Tournament 2004 content sometimes unpacks into the standard directory structure, and other times may unpack into it's own sub-directory, depending on the specific mod's requirements (pathing information in this case is available via the UMOD file)
    • dependencies:

      • I think this one will always be tricky. I would again suggest the ability to toss the user's selected file/archive/package at function, which has the responsibility of querying that content, either using established mod package formats which provide dependency information, or by other means (in the Unreal case we can do this by querying Unreal Archive to get a list of required files/packages).
      • the implementation of that dependency checking function would likely need to be able to interrogate already installed mods, mods selected for installation, and the actual target game's filesystem contents to see what's there and what's required
      • output from this process might need to feed back something that can be fed to further metadata or perhaps a search API which can resolve the things the user needs to install to solve the requirements
    • [optional] search:

      • provide some sort of game-specific search hook that can find things using custom search implementations which query variable backends for results and offers information/download options
      • I'm only really listing this here since it feels like it makes sense within the context of the dependencies API

    I think providing this functionality would allow people like myself to implement and extend richer support for somewhat esoteric or "legacy" games and formats beyond just "select zip file and extract file extension .xyz into directory /abc/".

    Reviewed by shrimpza at 2022-05-23 07:44
A diff-based data management language to implement unlimited undo, auto-save for games, and cloud-apps which needs to retain every change.

Docchi is a diff-based data management language to implement unlimited undo, auto-save for games, and cloud-apps which needs to save very often. User'

Jan 19, 2022
Open-source compiler for the Papyrus scripting language of Bethesda games.

Open Papyrus Compiler This project is still WORK IN PROGRESS. If you have any feature requests, head over to the Issues tab and describe your needs. Y

Jun 23, 2022
Shared memory - A Rust wrapper around native shared memory for Linux and Windows

shared_memory A crate that allows you to share memory between processes. This crate provides lightweight wrappers around shared memory APIs in an OS a

Jun 8, 2022
Terminal UI that allows Alacritty users to quickly and easily shuffle through provided themes 🦄

Alac-pretty alac-pretty.mp4 If you're like me in that you constantly need to change the colors of your dev environment because visual stagnation reall

Apr 17, 2022
argmax is a library that allows Rust applications to avoid Argument list too long errors (E2BIG) by providing a std::process::Command wrapper with a

argmax argmax is a library that allows Rust applications to avoid Argument list too long errors (E2BIG) by providing a std::process::Command wrapper w

Jun 13, 2022
FastSSH is a TUI that allows you to quickly connect to your services by navigating through your SSH config.
FastSSH is a TUI that allows you to quickly connect to your services by navigating through your SSH config.

Connect quickly to your services ?? FastSSH is a TUI that allows you to quickly connect to your services by navigating through your SSH config. Instal

Jun 14, 2022
Rust crate that allows you to display status & progress information in a terminal

status-line This crate allows you to display status & progress information in a terminal This crate handles the problem of displaying a small amount o

Jan 13, 2022
Allows processing of iterators of Result types

try-continue try-continue provides one method, try_continue, which allows you to work with iterators of type Result<T, _>, as if they were simply iter

Dec 26, 2021
⏱ Kubernetes operator that allows to set maximum lifetime for pods

Pod Lifetime Limiter Hi! ?? So you deal with a crappy application which stops working after some period of time and you want to restart it every N hou

Jun 11, 2022
A native screenshot tool for wlroots based compositors such as sway and river written in Rust
A native screenshot tool for wlroots based compositors such as sway and river written in Rust

A native screenshot tool for wlroots based compositors such as sway and river written in Rust. X11 support coming soon.

Jun 10, 2022
🦀️atos for linux by rust - A partial replacement for Apple's atos tool for converting addresses within a binary file to symbols.

atosl-rs ??️ atos for linux by rust - A partial replacement for Apple's atos tool for converting addresses within a binary file to symbols. tested on

Jun 4, 2022
Native cross-platform full feature terminal-based sequence editor for git interactive rebase.
Native cross-platform full feature terminal-based sequence editor for git interactive rebase.

Native cross-platform full feature terminal-based sequence editor for git interactive rebase.

Jun 18, 2022
Cucumber testing framework for Rust. Fully native, no external test runners or dependencies.
Cucumber testing framework for Rust. Fully native, no external test runners or dependencies.

Cucumber testing framework for Rust An implementation of the Cucumber testing framework for Rust. Fully native, no external test runners or dependenci

Jun 22, 2022
Pure-Rust rewrite of the Linux fontconfig library (no system dependencies) - using ttf-parser and allsorts

rust-fontconfig Pure-Rust rewrite of the Linux fontconfig library (no system dependencies) - using allsorts as a font parser in order to parse .woff,

Mar 26, 2022
Use Git installed in Bash on Windows/Windows Subsystem for Linux (WSL) from Windows and Visual Studio Code (VSCode)

WSLGit This project provides a small executable that forwards all arguments to git running inside Bash on Windows/Windows Subsystem for Linux (WSL). T

Jun 19, 2022
A simple guide for optimizing linux in detail

Optimizing Linux I am writing this guide as to save my progress and let others contribute to increase the performance even further, after all many are

Jun 23, 2022
Check the reproducibility status of your Arch Linux packages (read-only mirror)
Check the reproducibility status of your Arch Linux packages (read-only mirror)

arch-repro-status A CLI tool for querying the reproducibility status of the Arch Linux packages using data from a rebuilderd instance such as reproduc

May 19, 2022
Basic template for an out-of-tree Linux kernel module written in Rust.

Rust out-of-tree module This is a basic template for an out-of-tree Linux kernel module written in Rust. Please note that: The Rust support is experim

Jun 20, 2022
Sytéme d'AutoCompletion de texte pour HeficienceOS est autres distributions linux.

AutoCompletion Pour linux Version: 0.1.0-dev.1 - Note : L'application est encore instable, il est donc recommandé d'être indulgent, l'application risq

Jan 12, 2022