https://github.com/yggdrasil-au/remakeengine
The Game Remake Engine
https://github.com/yggdrasil-au/remakeengine
game-development remake-engine reverse-engineering
Last synced: 11 days ago
JSON representation
The Game Remake Engine
- Host: GitHub
- URL: https://github.com/yggdrasil-au/remakeengine
- Owner: yggdrasil-au
- License: apache-2.0
- Created: 2025-09-28T10:34:43.000Z (6 months ago)
- Default Branch: main
- Last Pushed: 2026-02-24T11:54:49.000Z (about 1 month ago)
- Last Synced: 2026-02-24T16:46:23.322Z (about 1 month ago)
- Topics: game-development, remake-engine, reverse-engineering
- Language: C#
- Homepage: https://yggdrasil-au.github.io/RemakeEngineDocs/
- Size: 25 MB
- Stars: 1
- Watchers: 0
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: Readme.md
- Contributing: CONTRIBUTING.md
- License: LICENSE
- Agents: AGENTS.md
- Cla: CLA.md
Awesome Lists containing this project
README
# Remake Engine
Remake Engine is an extensible cross-platform orchestration engine for repeatable game workflows. It ships with a .NET 10 core (**EngineNet**) that can run through either a command-line interface or TUI or an Avalonia-based GUI.
## Key Features
- Configuration-driven operations defined in JSON or TOML (`operations.json` / `operations.toml`).
- Embedded Lua, JavaScript, and Python engines (heavily focused on Lua, with minimal JS/Python support) with shared SDK helpers plus built-in extract/convert actions.
- Cross-platform GUI for "run all" and launch scenarios, alongside full TUI experiences for power users.
- Declarative placeholders that pull values from `project.json` to keep per-user paths out of manifests.
- Tool orchestration for common pipelines (QuickBMS, FFmpeg, vgmstream, etc.).
## Documentation
Project docs live at with a web page
## Getting Started
### Prerequisites
- [.NET SDK 10.0](https://dotnet.microsoft.com/en-us/download/dotnet/10.0)
- git
### Clone and Build
```pwsh
git clone https://github.com/yggdrasil-au/RemakeEngine.git
cd RemakeEngine
# Build and run tests (solution-wide)
dotnet build RemakeEngine.sln -c Debug
dotnet test Unit.Tests/EngineNet.Tests.csproj -c Debug --no-build --logger "trx;LogFileName=test_results.trx"
```
### Run the Engine using one of the three UX options
```pwsh
# Default entry point (auto-selects GUI when no CLI args are supplied)
dotnet run -c Release --framework net10.0 --project EngineNet
# Use GUI or interactive CLI (TUI)
dotnet run -c Release --project EngineNet --framework net10.0 -- --gui
dotnet run -c Release --project EngineNet --framework net10.0 -- --tui
# CLI example, great for direct operation invocations
dotnet run -c Release --project EngineNet --framework net10.0 -- --game_module "EngineApps/Games/demo" --script_type lua --script "{{Game_Root}}/scripts/lua_feature_demo.lua"
```
### Quick Demo Run
Run the demo module’s Lua feature script with arguments as used for development validation:
```pwsh
dotnet run -c Release --project EngineNet --framework net10.0 -- \
--game_module "./EngineApps/Games/demo" \
--script_type lua \
--script "{{Game_Root}}/scripts/lua_feature_demo.lua" \
--args "[\"--module\", \"EngineApps/Games/demo\", \"--scratch\", \"EngineApps/Games/demo/TMP/lua-demo\", \"--note\", \"Hello from the Lua demo\"]"
```
## Continuous Integration & Releases
GitHub Actions workflows in `.github/workflows/` keep pull requests, SonarCloud analysis, and tagged releases healthy:
| Workflow | Trigger | What it runs |
| --- | --- | --- |
| `build.yml` | Pushes to `main`, PRs | Windows build with SonarCloud analysis using the runner-hosted scanner cache. |
| `global-release.yml` | Tags matching `v*`, manual dispatch | Matrix builds/tests on Windows, macOS, and Linux across Debug/Release, then publishes self-contained artifacts for six runtimes and attaches them to a GitHub Release. |
| `on commit -- Win64 Build.yml` | Tags matching `win-v*`, manual dispatch | Windows-only Debug/Release build + test followed by a packaged `win-x64` release artifact. |
Run `dotnet build RemakeEngine.sln` and `dotnet test RemakeEngine.sln --nologo` locally before opening a PR so the CI checks stay green. To cut a multi-platform release, push a tag like `v2.5.0`; for a Windows-only drop use `win-v2.5.0`. The workflows create the release entry and upload the zipped outputs automatically.
## Interfaces
* **Simple GUI (Avalonia):** intended for end-users wanting a straightforward way to run predefined operations for their games/modules, to just run all primary operations, then to launch the game after.
* **Interactive TUI:** Menu-driven experience that lists games, prompts for answers, and streams operation output.
* **Developer CLI:** Direct command invocation for bespoke automation or module authoring. Arguments map to the same structures used by `operations.(json|toml)`.
## Configuration and Modules
* `EngineApps/Games//operations.(json|toml)` define operations for a game/module. Groups inside these files control execution ordering.
* `EngineApps/Games//config.toml` can supply placeholder values consumed by scripts and built-in actions.
* `project.json` (auto-created on first run if missing) stores per-user settings such as project paths and tool overrides.
* `Tools/` contains shared binaries or helper scripts. Module manifests declare dependencies that the engine can download via `ToolsDownloader`.
Schemas and documentation are included to help author and validate manifests in editors:
* `schemas/operations.toml.md` — comprehensive guide for operations files, explaining prompts, placeholders, and operation dependencies
* `schemas/operations.schema.json` — operations files (JSON)
* `schemas/config.schema.json` — engine configuration
* `schemas/game.schema.json` — game/module metadata
* `schemas/tools.schema.json` — tools manifests
Manifest placeholders follow `{{PlaceholderName}}` syntax and are resolved with data from the engine config, module metadata, and TOML placeholder tables.
## Repository Layout
```text
RemakeEngine/
EngineApps/ # Game modules and Registries
Games/ # Game modules
demo/ # Demo game module
operations.toml # Sample operations manifest
config.toml # Sample per-module config
Registries/ # Module, Tool, and Operation registries
Modules/ # Module manifests
Tools/ # Tool dependency definitions
ops/ # Internal operation definitions for built-in actions (eg git download of Modules)
EngineNet/ # C# core engine and CLI entry point
schemas/ # JSON schemas
RemakeEngine.slnx # Solution
```
## Contributing
See [CONTRIBUTING.md](CONTRIBUTING.md) for contribution guidelines, coding standards, and release workflows. When modifying the engine, update the matching specification in `EngineNet/specs/` so documentation stays in sync with the implementation.
## Module Licensing Policy
RemakeEngine is licensed under Apache 2.0 and may be used freely, including for commercial projects.
However, modules that target copyrighted games or other proprietary media must respect our **Non-Commercial Module Policy**:
* To be listed as an officially supported module, the module must use a custom Non-Commercial License.
* Modules under OSI-approved commercial-use licenses will not be listed in the official registry **if they target protected media** unless they prove they are legally permitted to do so.
See LICENSE_MODULE_TEMPLATE.md for the recommended license text.
## License & Legal
apache-2.0 for the engine core and all code in this repository, but modules must use a custom non-commercial license if they target protected media.
See [LICENCE](LICENCE)