SoupRune

Status: 🚧 Initial development phase (framework structure is still evolving rapidly)

SoupRune is an experimental game framework designed specifically for creating RPG / STG games similar to Deltarune / Undertale.

English	Simplified Chinese
English Version	简体中文

🥣 Introduction

Hey, don’t be scared by that “Rust” badge above — SoupRune isn’t just a niche tool for hardcore programmers!

Why is that? Because:

SoupRune is a Language-Agnostic Framework!

SoupRune adopts a Framework - Project (Mod) architecture. The core engine built with bevy handles the low-level execution, while your game logic resides in an independent "Project" that interacts with the core via standard interfaces.

We achieve true Language-Agnosticism through the C ABI. In choosing supported languages, we prioritize those friendly to traditional Undertale / Deltarune developers, aiming to build a bridge for developers from **GameMaker ** (Haxe), Lua (Nelua), or Python / GDScript (Nim) backgrounds.

We warmly welcome developers from all language communities to join us in improving support for these languages!

SoupRune is a Community-Oriented Framework!

SoupRune — the “Rune” in the name isn’t just random.

While the Undertale fangame framework space may already be saturated, the Deltarune community is thriving.

SoupRune was created to seize this opportunity as a fangame framework, while also serving as a spiritual successor to Undertale Changer Template.

But that doesn’t mean SoupRune is only a Deltarune framework — we also value support for Undertale fangames!

SoupRune aims to become a true “community-oriented fangame framework” — open, flexible, modern, yet still retaining that familiar DR / UT style.

SoupRune is an Open Source Framework!

SoupRune uses the LGPL-3.0 license. This license applies only to the framework core code.

This means:

• The Project (Mod) you develop can use other open-source licenses or be closed-source;
• You can use SoupRune's source code in closed-source projects;
• But if you modify the framework's core code, you must release those changes under the LGPL;
• If you wish to use modified SoupRune core code in a fully closed-source environment, you can contact me for a commercial license.

Additionally, you must still follow Toby Fox’s rules for fan games.

SoupRune is an Experimental Framework!

Although "experimental" implies instability and imperfection, it also represents infinite possibilities.

Use it to make a dr / ut fangame? Or try to recreate other classic games? Or even develop a brand new original game? Anything is possible!

SoupRune is currently still in the initial development phase, and the framework structure and design philosophy are evolving rapidly. We welcome community members to actively participate in discussions and contributions to shape the future of this framework.

Join our Discord!

🧭 S.O.U.P Principles

Yes, SoupRune is a pun — and here’s what it stands for:

Abbreviation	Full Form	Meaning
S	Strong	Built on Bevy and Rust, powerful and modern architecture.
O	Open	Uses the LGPL open-source license, allowing free use and extension.
U	User-friendly	Offers multi-language scripting to lower the learning curve.
P	Polyglot	Supports multiple programming languages (Rust, C#, Haxe, Nim, Nelua, etc.).

⚙️ Technical Foundation

• Core built with Bevy engine and Rust, ensuring performance and extensibility;
• Design goals: clear structure, modular expansion, and easy customization.

🏗️ Project Architecture

SoupRune adopts a multi-crate workspace architecture:

Crate	Description
souprune	Core Framework: The main framework body, application entry point, and core logic.
souprune_api	Protocol Layer: Defines interface standards for Project (Mod) interaction with the core.
souprune_sdk	Development Kit: A wrapper for the API, provided for external Project (Mod) scripts.
souprune_mod_test	Sample Mod： Sample test library for scripting systems.
bevy_mortar_bond	Plugin: Bridge between Mortar scripting and Bevy, handling dialogue and logic.
bevy_ecs_typewriter	Plugin: ECS-based typewriter implementation, supporting rich text and multi-language.
bevy_fact_rule_event	Plugin: Complex event system based on the "Fact-Rule-Event" model.

🧩 Script Layer Support

SoupRune's scripting system is built on C ABI to achieve high-performance interoperability. We have carefully selected a series of languages that support AOT compilation, aiming to correspond to different development paradigms so that developers from other engines can smoothly migrate their experience:

Language	Target Users	Description
Rust	System-level developers / Rustaceans / Bevy users	Native support, best performance.
.NET (C#)	Unity / Godot / C# users	Industry standard language. Seamless integration and high performance via Native AOT.
Haxe	Haxe users / GameMaker users	Powerful high-level language. Its syntax is similar to GML, making it an excellent choice for development.
Nim (Coming Soon)	Python / GDScript (Godot) users	Python-like indentation syntax, compiles to C, combining elegance with efficiency.
Nelua (Coming Soon)	Lua users	Inherits Lua's minimalist syntax style but compiles to native machine code for extreme performance.

If you are interested in helping with SoupRune's multi-language support, contributions are welcome!

Citation Instructions

This project uses the following open-source projects as libraries, dependencies, or references:

Original Games

Project	Description
Undertale	UNDERTALE Original Game
Deltarune	DELTARUNE Original Game

Predecessor

Project	Version	License	Description
Undertale-Changer-Template	1.0.7		SoupRune is the spiritual successor of Undertale-Changer-Template, continuing its core concepts and design philosophy.

Game Engine Core

Project	Version	License	Description
Bevy	0.17.2		Game Engine Core

Bevy Plugin Ecosystem

Project	Version	License	Description
bevy_ecs_typewriter	0.0.0		Typewriter implementation based on ECS
bevy_fact_rule_event	0.0.0		Implementation of an event system based on fact-rule-event
bevy_mortar_bond	0.0.0		A bridge library between Bevy and the Mortar language
leafwing-input-manager	0.19.0		Manages game input, handling keyboard, mouse, and controller operation mappings
seldom_state	0.15.0		Finite State Machine implementation
bevy_ecs_tiled	dev (GitHub branch)		Integrates Bevy ECS and Tiled map editor for tile-based game levels
bevy_tween	0.10.0		Tweening animation library for Bevy, used for smooth animations and transitions
bevy-inspector-egui	0.35.0		Optional editor/debugging tool for Bevy, used for real-time inspection of the ECS world
iyes_perf_ui	dev (My fork based on GitHub PR #35 )		Optional performance monitoring UI for Bevy, displaying FPS, system timings, and profiling information
bevy_smud	0.12.0		2D SDF shape renderer plugin for Bevy
bevy_rich_text3d	0.5.1		Mesh-based rasterized rich text implementation
bevy_kira_audio	0.24.0		Audio playback plugin using Kira, supports WAV, OGG, FLAC, MP3 formats
bevy_brp_extras	0.17.2		Extra features for Bevy Remote Protocol (BRP)

Rust Crates

Project	Version	License	Description
serde	1.0		Serialization/deserialization framework supporting derive macros for convenient (de)serialization of structs
toml	0.9.8		TOML parsing
ron	0.10		Rusty Object Notation parsing

Asset References

Project	Description
DTTVL-Fonts	Font files used in the DELTATRAVELER localization project

Heartfelt thanks to every contributor to the project! 🎔

Contributors

The following individuals have contributed to the project.

Heartfelt thanks to each and every one of you! 🎔

🤝 Join Us

Whether you:

• Want to create your own DR/UT-style game;
• Want to try Bevy and Rust;
• Or simply love open-source and experimentation —

You’re welcome to contribute to SoupRune:

• Submit Issues or Pull Requests!
• Share ideas and discuss architecture!
• Or just chat about game development in the community!

Let’s cook the most delicious Soup together!