Release notes

Versioning

Support policy

uMod 1.0

Core

Universalization

Introducing a single coherent vision to supercede Oxide with fundamental improvements to the deployment strategy and implementation of every major system, resulting in a more reliable, flexible and performant modding platform.

Unit Testing

Introducing an automated testing suite for core development and universal plugin development. Improvements and updates may now be vetted properly ensuring that each update fulfills all requirements.

New compiler

A new Roslyn-based compiler has replaced the old mono compiler. C# 9 features are now supported in plugins.

New web client

A new standalone web client comes bundled with uMod which enables web requests to be made using the latest security standards available regardless of game limitations.

New database client

A new standalone database client has replaced Oxide.MySql and Oxide.Sqlite. The database client can be accessed by an asynchronous API and includes an object-relational mapper.

TOML support

Configuration files and localization files may now use TOML (Tom's Obvious Markup Language) format in addition to JSON.

New auth drivers

New configuration options to store player and group data in a database (Sqlite or MySql), JSON, or protobuf files.

Logging configuration

Logs are now stored as .log files. Logging behavior including log formats and locations may now be configured. Multiple loggers may now be combined using the stack driver. The new logging drivers include stack, single, daily, unity, and sentry.

Run-time string interpolator

Aside from existing formatting options (such as string.Format and compile-time interpolation), a run-time string interpolator was added that allows for dynamically named parameters.

Plugins

Added configuration/localization schematics

Configuration schematics are now properly supported in uMod as the default way to shape configuration and localization files.

Added file versioning

Configuration and localization files are now versioning and file upgrades may be implemented using the new OnConfigUpgrade and OnLocaleUpgrade hooks.

Added locale schematics

Locales provide a simple way to scaffold localization much in the same way configuration schematics are implemented.

Added Hook Decorators

A hook decorator is a simple wrapper which allows for contained hooks to be managed separately and as a group.

Improved OnlinePlayers

The OnlinePlayers system is now an optional hook decorator that works for all uMod-supported games. The hooks used will not exist unless OnlinePlayers is used, which should slightly improve performance for plugins which do not use OnlinePlayers. OnlinePlayers now supports an IPlayer key type (in addition to the game-specific GamePlayer types).

Gates

Introducing Gates to provide a simple way to authorize any hook or command using custom policies or permissions.

Command localization

Command names, descriptions, and help text may be localized using the new locale provider or the legacy lang provider.

Hooks

Dependency injection

Hook parameters may now inject parameters from the service container in addition to the originally provided arguments.

Parameter substitution

IPlayer and GamePlayer* are now interchangable in all hook methods. Custom substitutions may also be implemented.

Hook generics

Type constraints are now respected in hook signatures when matching hooks.

Hook events

Hook events contain state information that is passed through all hooks in any given call-stack which allows for better integration and the ability to more easily avoid hook conflicts.

Hook decorators

Hooks may be separated into decorators which allow for multiple hooks to be managed, subscribed, and unsubscribed simultaneously.

Hook namespacing

Hooks may now be namespaced to allow for the simple separation of concerns within a single plugin.

Dependencies

Plugins may now name multiple plugins for a single dependency field.

Options and requires

The PluginReference attribute (used for plugin integration) was deprecated and replaced with Optional and Requires attributes. A PluginReference is roughly analagous to an Optional dependency, and Requires is a similar concept except that it ensures a dependency is loaded. A dependency marked Requires should not be confused with hard dependencies in Oxide that used // Requires comment annotations. Duck-typing was added to more easily allow for the communication of type information between plugins which replaces // Requires.

Duck typing

Introducing duck typing to make optional explicit dependencies, a type of very performant (and completely optional) plugin dependency.

Type promises

When a plugin fails to compile due to a missing type, uMod will automatically check any subsequent compilations for the existence of the missing type. If the missing type is found then the plugin that originally failed will be re-compiled.

Async

Promises

Asynchronous multi-threaded operations are now easily supported via promises across all games using promises, even ones without async/await.

FileSystem

A new API for interacting with the filesystem and data files is now available with asynchronous I/O.