Options
All
  • Public
  • Public/Protected
  • All
Menu

Wayward

Modding Guide

Table of Contents

Intro

Wayward is primarily built using HTML5 technologies and uses TypeScript (a strict superset of JavaScript), which compiles down to normal JavaScript. This is then run through Electron, a cross-platform application that runs browser languages as a desktop app, outside of your browser.

You are not required to use TypeScript in your mods; however, it will become harder to maintain and manage your mods using standard JavaScript. Plus, with TypeScript you will get auto completion on all our internal functions and hooks. TypeScript also has strict compilation and error checking, removing a lot of debugging work. This guide is only tailored towards building TypeScript modifications for Wayward.

Wayward uses a combination of HTML, CSS, JavaScript, and WebGL (shaders) for all rendering and UI. It is not necessary to have skills and knowledge in these things to begin modding, although it wouldn't hurt.

NOTE: Wayward modding support is Early Access (or beta), just like Wayward itself. Many things will change and improve over time. Let us know any issues you run into or if you have any ideas for us.

Workflow/Editor

Follow along in this section if you are not familiar with TypeScript. To compile and write mods for Wayward, you will need an IDE or editor that supports TypeScript. If you are comfortable with the likes of Node.js and NPM you can set up TypeScript yourself with a variety of editors including Sublime, Atom, WebStorm, Visual Studio and more. Visit the TypeScript website for more information. This guide will use a Visual Studio Code setup below if you need help getting started.

Visual Studio Code

Visual Studio Code is a free, cross-platform, open source editor from Microsoft written with JavaScript and deployed via Electron, just like Wayward! It has built-in support for TypeScript.

Download Visual Studio Code here: https://code.visualstudio.com/download

Install it with the default options/settings.

Node.js/NPM/TypeScript

Before you can build/compile in Visual Studio Code (or other editors/IDEs) you will need Node.js (with NPM) and TypeScript. Download and install Node.js (using the default installation settings): https://nodejs.org/en/download/

Once you install Node.js, you will have access to NPM, or "Node Package Manager", which allows you to install TypeScript. Open your terminal (Linux/Mac OS X) or command prompt (Windows) and run the following command:

npm install -g typescript

Examples

All official Wayward modifications are open source, allowing you to see how to mod various elements of Wayward. We have a GitHub organization with repositories for all our mods and examples located here: https://github.com/WaywardGame

If you are familiar with Git and/or GitHub, checking out or cloning the repositories should be fairly self-explanatory. If you are not familiar, you can simply browse the files in each repository for the mods. Clicking on the files will display their contents. There is also a "Download ZIP" option after clicking the "Clone or download" button, located near the top right hand side of each of the main repository pages which will download a .zip file, containing all the resources to view the files and edit them on your computer.

If you are not familiar with Git or GitHub at all and want to learn, we would suggest you try out GitHub Desktop: https://desktop.github.com/

GitHub Desktop also has a handy help section to you get started:

Hooks & Methods

Wayward features a suite of methods to be used when making mods, adding new functionality into the game. Such things as adding keybinds, messages, items, and more are all done through our provided methods.

A full listing of the methods and hooks provided out of the box can be found in the mod class: Class Mod

The main functionality of Wayward modding comes from hooks. Hooks are special places in our code where we have enabled mods to overwrite or modify functionality within Wayward. If you are not familiar with hooks, you will see how they can be used in the Hello World section below.

For a listing of the game's hooks (details of which can be seen in the Mod class), view the full enumeration: Enumeration Hook

Hello World

Intro

This section assumes you have an editor capable of compiling TypeScript files, and uses Visual Studio Code as a reference for keybinds and functionality. It should also be noted that this is not a TypeScript tutorial. If you want to learn the TypeScript language, please read through the official Handbook.

The first step of developing a Wayward modification is setting up the primary files. You can skip this guide and file setup by downloading/checking out (via GitHub) the Hello World mod in its entirety here: https://github.com/WaywardGame/helloworld

For the sake of this tutorial, we will use the "mods" directory within the Wayward Steam directory as the base for your modification. You can get there by clicking the "Open Mods Folder" button inside of the "Manage Mods" menu while in Wayward. Alternatively, you can right-click Wayward from your Steam library and click "Properties". From there you can click the "Local files" tab and select "Browse local files". You are looking for the folder called "mods" within the Wayward folder/directory.

Setup

After you are inside the "mods" folder, create a new folder called "helloworld". Inside there, create the following files and folders:

  • /.vscode/tasks.json
  • /mod-reference/
  • mod.json
  • tsconfig.json
  • HelloWorld.ts

NOTE: Having trouble creating a .vscode folder in Windows? Take a look in the Frequently Asked Questions for the solution.

helloworld/.vscode/tasks.json

Visual Studio Code needs to know that we want to build our mods with TypeScript. Adding a tasks.json file in a new folder named ".vscode" with the following inserted will build your project with Ctrl+Shift+B.

{
    "version": "0.1.0",
    "command": "tsc",
    "isShellCommand": true,
    "showOutput": "silent",
    "args": [],
    "problemMatcher": "$tsc"
}

helloworld/mod-reference/

The contents of this folder is located here: https://github.com/WaywardGame/mod-reference/

Refer to the Examples section if you are not familiar with GitHub.

It is recommended you keep this up to date with what is located on GitHub as this will change from version to version of Wayward. This folder contains all the definitions for functions in Wayward so that TypeScript can autocomplete and compile your mod properly.

helloworld/mod.json

You can think of the mod.json file as the description file for your mod. It describes what it does and how it behaves. It does this through a set of properties, which we will describe below. It should be updated every time you publish it to Steam. Here's a sample of what it should look like for Hello World:

{
    "name": "Hello World",
    "description": "Hello World is an example mod, shown in the Modding Guide, located here: https://waywardgame.github.io/",
    "version": "1.0.0",
    "author": "Your Name Here",
    "compatibleMinorVersions": [
        3
    ],
    "unloadable": true,
    "file": "HelloWorld.js",
    "hooks": [
        "OnGameStart",
        "OnItemEquip",
        "OnMove"
    ]
}

The following is an explanation of the properties in this mod.json file:

compatibleMinorVersions only allows the mod to load in 2.3.x.

unloadable makes it so the mod doesn't have to be enabled when loading a world which had the mod loaded previously.

hooks is a list of places in the code we're going to be injecting our own code into.

To see a complete list of the properties you can use in your mod.json, and more in-depth details of the properties used in this example, see the mod.json section.

helloworld/tsconfig.json

tsconfig gives instructions for how TypeScript should compile your project.

{
    "compilerOptions": {
        "target": "es6",
        "module": "amd",
        "declaration": true,
        "noImplicitAny": true,
        "removeComments": true,
        "preserveConstEnums": true,
        "sourceMap": true,
        "baseUrl": "./mod-reference/definitions",
        "types": []
    }
}

This will be the same across all your mods generally. If you want to know more on tsconfig, review the official documentation on it here.

helloworld/HelloWorld.ts

Finally we get to the actual functionality and coding of our mod in HelloWorld.ts. Let's start with the basics.

import Mod from "mod/Mod";

export default class HelloWorld extends Mod {
    public onLoad(saveData: any): void {
    }

    public onUnload(): void {
    }
}

Here we start by importing the "Mod" class which will allow us to extend it with our new "HelloWorld" class. This is where the next bit comes in. We use an export default class where we will include the hooks that we use in our mod. Let's start off by declaring the onLoad and onUnload hooks.

If you are having issues with figuring out the names and/or paths of imports, please read about our solution with TSLint.

Please note that the onInitialize, onUninitialize, onLoad, onUnload, and onSave are special/default hooks that do not need to be defined in the "hooks" listing within the mod.json file. They will be executed whether or not you directly use them in your modification.

  • onInitialize is executed as Wayward is loaded (or your mod is enabled via the mod manager). You can setup your custom functionality within it or load and interact with global save data.
  • onUninitialize is executed when your mod is disabled via the mod manager. Making use of this hook will allow users to disable and enable the custom functionality of your mod at will.
  • onLoad is executed when you load a Wayward save (or start a new game). This is where the bulk of your modding methods are defined. Things like adding customs messages, adding new items or actions, etc.
  • onUnload is executed when the current game is unloaded (user quits the game or goes back to the main menu). You can use it to remove features the mod added that may persist unintendedly into the next load.
  • onSave is called before onUnload and is used to perform saving functionality.
import { MessageType } from "language/Messages";
import Mod from "mod/Mod";

export default class HelloWorld extends Mod {
    private helloWorld: number;

    public onLoad(saveData: any): void {
        console.log("Hello World!");

        this.helloWorld = this.addMessage("HelloWorld", "Hello World!");
    }

    public onUnload(): void {
        console.log("Goodbye World!");
    }

    // Hooks
    public onGameStart(isLoadingSave: boolean, playedCount: number): void {
        ui.displayMessage(localPlayer, this.helloWorld, MessageType.Good);
    }
}

Here's where the name of the mod comes from. As you can see, we added new message to the game. It will display "Hello World!" when you start a new game, hence the new onGameStart hook. We also added some console logs to the game. These will not be shown to the player, but can be useful for debugging or logging information. They will only show when you have your console open. Because we needed to use the MessageType enum, you can see we also imported it from "language/Messages". Let's add some more functionality:

import { EquipType, ItemType } from "Enums";
import { IItem } from "item/IItem";
import Items from "item/Items";
import { MessageType } from "language/Messages";
import Mod from "mod/Mod";

export default class HelloWorld extends Mod {
    private helloWorld: number;
    private helloLeftHand: number;
    private helloRightHand: number;

    public onLoad(saveData: any): void {
        console.log("Hello World!");

        this.helloWorld = this.addMessage("HelloWorld", "Hello World!");
        this.helloLeftHand = this.addMessage("HelloLeftHand", "Hello Left Hand!");
        this.helloRightHand = this.addMessage("HelloRightHand", "Hello Right Hand!");
    }

    public onUnload(): void {
        console.log("Goodbye World!");
    }

    // Hooks
    public onGameStart(isLoadingSave: boolean, playedCount: number): void {
        ui.displayMessage(localPlayer, this.helloWorld, MessageType.Good);
        Items[ItemType.Branch].prefix = "a ";
        Items[ItemType.Branch].name = "greetings stick";
    }

    public onItemEquip(item: IItem, slot: EquipType): void {
        if (item.type === ItemType.Branch) {
            if (slot === EquipType.LeftHand) {
                ui.displayMessage(localPlayer, this.helloLeftHand, MessageType.None);
            } else {
                ui.displayMessage(localPlayer, this.helloRightHand, MessageType.None);
            }
        }
    }
}

Now we have renamed the branches in the game to "a greetings stick". We added a new hook (onItemEquip) so that when we equip them, they say hello to our hands. Why? There's so many reasons I don't know where to start! As we add functionality, you can see we continue to import enums and classes as we need to. Let's continue:

import { EquipType, FacingDirection, ItemType } from "Enums";
import { IItem } from "item/IItem";
import Items from "item/Items";
import { MessageType } from "language/Messages";
import Mod from "mod/Mod";
import { ITile } from "tile/ITerrain";
import Terrains from "tile/Terrains";
import * as Utilities from "Utilities";

export default class HelloWorld extends Mod {
    private helloWorld: number;
    private helloLeftHand: number;
    private helloRightHand: number;
    private helloTerrain: number;

    public onLoad(saveData: any): void {
        console.log("Hello World!");

        this.helloWorld = this.addMessage("HelloWorld", "Hello World!");
        this.helloLeftHand = this.addMessage("HelloLeftHand", "Hello Left Hand!");
        this.helloRightHand = this.addMessage("HelloRightHand", "Hello Right Hand!");
        this.helloTerrain = this.addMessage("HelloTerrain", "Hello _0_!");
    }

    public onUnload(): void {
        console.log("Goodbye World!");
    }

    // Hooks
    public onGameStart(isLoadingSave: boolean, playedCount: number): void {
        ui.displayMessage(localPlayer, this.helloWorld, MessageType.Good);
        Items[ItemType.Branch].prefix = "a ";
        Items[ItemType.Branch].name = "greetings stick";
    }

    public onItemEquip(item: IItem, slot: EquipType): void {
        if (item.type === ItemType.Branch) {
            if (slot === EquipType.LeftHand) {
                ui.displayMessage(localPlayer, this.helloLeftHand, MessageType.None);
            } else {
                ui.displayMessage(localPlayer, this.helloRightHand, MessageType.None);
            }
        }
    }

    public onMove(nextX: number, nextY: number, tile: ITile, direction: FacingDirection): boolean | undefined {
        const getTile = game.getTile(localPlayer.x, localPlayer.y, localPlayer.z);
        const tileType = Utilities.TileHelpers.getType(getTile);
        ui.displayMessage(localPlayer, this.helloTerrain, MessageType.Stat, Terrains[tileType].name);
        return undefined;
    }
}

Now we say hello to the world, literally. As your player moves, you will say hello to the ground beneath your feet, by name!

You can compile your script with "Ctrl+Shift+B" by default. After it is compiled, you will see a bunch of new files in your helloworld directory. These are the files Wayward will use. If you load Wayward, under "Manage Mods", you will now see your Hello World mod under "Local Mods".

It's not much of a mod, but it works!

JSON Specifications

Besides the required mod.json file, Wayward has support for a variety of JSON files that add/modify functionality without the need for coding and compiling a full modification. Currently, there is support of image replacements, language translations, and character customizations. This section will elaborate on the various JSON files you may need to write when making a Wayward mod.

mod.json

The mod.json file is what tells Wayward that your mod folder is a mod, and provides information such as the version it can run on, the version it is, its name, and more. The following is a specification of what properties will appear on your mod.json files.

compatibleMinorVersions will stop your mod from being loaded if the Wayward's game version doesn't match what is set in the array. If you have "1" set here, and Wayward beta version 2.1.0 is loaded, then it will run. If you have it set as "compatibleMinorVersions": [ 2 ], then it will only work in version 2.2.0. "compatibleMinorVersions": [ 1, 2 ] will load in both versions 2.1, and 2.2. You may omit this property if you always wants your mod to run, regardless of the game version (this is not recommended as our API changes between versions).

unloadable should be set to true if you are not adding new things into the game which modify the save data. If you are creating a mod that adds new monsters, items, doodads, terrain you will want to set this to false or omit it completely.

hooks will contain a list of Hooks which represent all the functionality you are modifying in Wayward. Refer to the Enumeration Hook page for the full listing. Please note that the hook names in this section must be fully CamelHump cased.

dependencies is a list of mods that your mod needs. For instance, if you wanted to extend the functionality of another mod, or use utility functions provided by them. The property takes an array of strings representing Steam Workshop IDs. Your mod won't be loaded if the dependencies aren't installed and enabled.

"dependencies": [
    "474819610"
]

imageOverrides is a property that will allow you to override default graphics in the game. When set to true ("imageOverrides": true), it will load a dedicated imageOverrides.json file containing the overrides. This property isn't required, as not providing it is the same as setting it to false.

languages is a property that will allow you to provide a language without requiring scripts. It takes an array of paths to language JSON files. Omitting the property loads no language files. The property will look like this:

"languages": [
    "pirateLanguage",
    "spaceLanguages/glaknarLanguage"
]

This example would attempt to load the language files <modName>/pirateLanguage.json and <modName>/spaceLanguages/glaknarLanguage.json

customizations is a property that will allow you to provide character customizations. When set to true ("customizations": true), it will load a dedicated customizations.json file containing the overrides. Omitting this property is the same as setting it to false.

stylesheets is a property that automatically appends CSS stylesheets as your mod is initialized, and removes them as your mod is uninitialized. It takes an array of strings representing the paths to your stylesheets. The property will look like this:

"stylesheets": [
    "mainStyle",
    "moreStyles/anotherStyle"
]

This example would attempt to load the language files <modName>/mainStyle.css and <modName>/moreStyles/anotherStyle.css. You can also see this property in action in our Developer Tools mod.

publishedFileId is a property that is automatically filled in after your mod is published to the Steam Workshop. Do not modify or manually add this property. Wayward will use this when you publish updates to your mod.

imageOverrides.json

The imageOverrides.json file will allow you to override default graphics in the game. The file is not required, and will only be loaded by setting the imageOverrides property of your mod.json to true.

Here is an example of how the file could look:

[
    {
        "replace": "doodad/tree",
        "imagePath": "doodad/specialTree"
    },
    {
        "replace": "doodad/treewithberries",
        "imagePath": "doodad/specialTreewithberries",
        "animated": true
    }
]

The replace property specifies the default graphic path, and the imagePath property specifies the mod's path for the image. The .png is appended automatically. If the imagePath property is not provided, it defaults to using the same path as replace.

The animated property takes a boolean representing whether or not the image is an animated strip. If the property isn't provided it defaults to false.

You can see an example of image overrides in action in the Trees on Fire mod.

language.json

A language json file contains all translations of a language, without requiring scripts, as was the case in versions < 2.3. The file name can be anything as long as it ends in .json Here's an example file:

{
    "name": "such language",
    "shouldPluralize": true,
    "dictionaries": {
        "item": {
            "branch": ["", "real branch", "wow very branch"]
        }
    }
}

A description of the properties follows.

name is the name players will see in the language selector dropdown.

shouldPluralize determines whether or not names should be pluralized.

extends is used to extend another language (such as English)--rather than providing the name parameter, you may provide this parameter, set to the name of the language you are extending (important--make sure extends is set to a string identical to the name parameter of the extended language, or else it will not work). When using extends, shouldPluralize has no effect. Dictionary entries afterwards will overwrite any entry already set in the language.

dictionaries is an object containing the dictionaries with translations. Each dictionary you provide is an object containing entries in the dictionary, which are arrays containing the translation.

The format of a translation is [string, string, string, string], where the strings, in order, represent the prefix, the name, the description, and the suffix.

You can see an example of custom languages provided via a JSON file in the Pirate Language mod.

customizations.json

The customizations.json file will allow you to provide extra customizations for character creation (hairstyles, hair colors, and skin tones). The file is not required, and will only be loaded by setting the customizations property of your mod.json to true.

Here is an example of how the file could look:

{
    "skin-colors": [
        "#ff0"
    ],
    "hair-colors": [
        "#ff0"
    ],
    "hair-styles": [
        "Braid",
        {
            "name": "Pigtails",
            "imagePath": "specialHairstyles/Pigtails"
        }
    ]
}

Skin colors and hair colors each take an array of strings representing colors in hex. The # is not required. When providing 3 characters, each character is doubled. For example, ff0 is the same as ffff00. This functionality mirrors the functionality of web browsers (CSS).

Hair styles takes an array of strings or objects. When a string is provided, the mod attempts to load the sprite from <modName>/static/image/hairstyle/<hairstyleName>.png. When an object is provided, if the imagePath property is set, it will use this as the path to the hairstyle sprite instead.

Top-level properties of the file can be left out if you have no customizations of that kind to provide.

You can see an example of customizations in action in the Ridiculous Hairdos mod.

Debugging

You can open the developer tools at any time within Wayward by clicking the "Toggle Developer Tools" button located in the bottom of the options menu. You can execute arbitrary code while this menu is opened, log console commands, explore native functions and definitions, inspect UI elements, and more.

If you want them to start open by default when you run Wayward, you can open the launch_options.json file within the root directory of Wayward on Steam, and change the following line: "devtools": false, to "devtools": true,.

We would also recommend subscribing to and enabling the "Developer Tools" mod, available on the Steam Workshop. This mod allows the changing of tiles, spawning of items, creatures, doodads, refreshing stats, adds noclip, allows killing of all creatures, and more! Furthermore, it adds an interface for refreshing mods within the bottom of the options menu while in-game on the fly so you don't have to reload the full game when testing a modification.

Publishing

After you are happy with your mod, why not publish it to Steam Workshop? You will be able to edit most things via the Steam interface after publishing it, but you'll want to include a few things before releasing it as described below.

NOTE: Please do not upload the Hello World modification to the Steam Workshop. Make something fun!

If you place a square formatted .png image in the root mod folder named "mod.png" this will be the thumbnail/main image for the mod when it gets uploaded to the Steam Workshop. We recommend a size of 720x720 pixels, although this gets shrunk down to around 77x77; but normally appears at 268x268 inside the Workshop page, so please use 268x268 as a minimum size.

When you are ready to go, and you have performed all the steps outlined in Hello World section, upon launching Wayward and going in the Manage Mods menu, you will see an "arrow" icon to the right hand side of your mod. Clicking it will allow you to publish your mod to the Steam Workshop. At any point you make changes and build/compile your mod, you can simply click this again to send an update to Steam.

Everything else about your entry is controlled via Steam. This includes uploading screenshots, links, required mod displaying, stats, and more. You can quickly get to your Workshop entry by clicking the "eye" icon next to your mod in the Manage Mods menu listing. You will see a full suite of administrative options on that page if you are logged in to Steam.

Extracting Wayward Assets

Want to extract the assets (or source files) from Wayward for modifications? The complete repository of Wayward files are located in the resources folder within the Wayward Steam directory, in an archive named "app.asar". This cannot be opened or extracted using conventional means; however, using NPM you can install a package to extract the files from this archive. Use the following command:

npm install -g asar

After it is installed, change directories to where the app.asar is located, for example:

cd "C:\Program Files (x86)\Steam\steamapps\common\Wayward\resources"

Next extract it using:

asar extract app.asar app

This will extract the full archive to a folder named "app" within the resources folder.

Full documentation on asar (Electron Archive) can be found here: asar - Electron Archive

Frequently Asked Questions

Visual Studio Code is showing errors (even in example mods) and/or cannot compile.

This is a common issue you may run into if you have followed this guide in the past but is now showing errors, even when copying over the new example mods/references. TypeScript updates will be a fairly constant thing in Wayward until TypeScript is more mature. It's possible your TypeScript installation is out of date.

You can check your current TypeScript version by opening your terminal (Linux/Mac OS X) or command prompt (Windows) and running the following command:

tsc -v

You can update it by running the install command again:

npm install -g typescript

Make sure to restart your editor before trying again.

How do I open the console in-game?

This is explained a bit in the Debugging section of this guide.

But in short: open the options menu, scroll near the bottom, and click "Toggle Developer Tools". This will open the Developer Tools which features the console.

Windows is showing a "You must type a file name." dialog when trying to rename a folder ".vscode".

You can bypass this limitation by downloading/cloning one of the example mods and just copying the .vscode folder for your own mod, or by creating the directory using the command prompt. To do so, change your directory to the location you wish to make the .vscode folder like so:

cd "C:\Program Files (x86)\Steam\steamapps\common\Wayward\mods\helloworld"

Then run the following:

mkdir .vscode

How to I upgrade my mod from version to version?

When we make significant changes to our codebase, for example: upgrading from ES5 to ES6 in beta 2.2, or moving to a modular codebase in beta 2.3, you may have to make many changes to your modification so that it runs on the latest version. This is an unfortunate side effect of still being in beta. As we move to towards a more stable, non-beta release, you may expect less of these huge changes.

As we make these changes, we always make sure our documentation (and this guide) is up to date and shows how to make mods for the current or upcoming version. You can always find the Hello World section showcasing how to create a very basic mod for the latest version. Also, we supply all our official modifications on GitHub as examples on what we do to update our own mods. You can browse the commits of each mod to see what we did as we upgraded to each Wayward version. You can even browse the repository for this guide to see what we are changing in our documentation from version to version.

How do I find out the name and path of imports?

If you are using Visual Studio Code, we recommend installing the TSLint extension. When typing names of interfaces, enums and more, TSLint will show a red squiggly line underneath if they are not imported already. After clicking on the definition/error/line, a small light bulb will appear in the left gutter. Clicking on this light bulb will allow you to automatically import the declaration. For example, typing:

ItemType

Should trigger an error with TSLint. Clicking on the line, then the light bulb, will show:

Add ItemType to existing import declarations from Enums.

or:

Import ItemType from Enums.

If you don't have any "Enums" import declarations yet. Clicking this option will add something like following to the top of your file:

import { ItemType } from "Enums"

I need more help!!!

Calm down! The community is here to help. Simply post your issue or problem in the Workshop discussion forum.

Want more of a real-time support approach? You can also try on Discord. Make sure to post in the #wayward-modding channel.

Disclaimer

By submitting a Workshop creation for Wayward, you understand that Wayward is a work in progress. As such, many things will change and be added over time. This can result in the following:

  • Your submission becoming obsolete.
  • Your submission breaking in functionality as updates are released.
  • Your submission becoming an eventual feature within the game.

In the case of breaking functionality, we will try our best to limit such things from happening; however, due to the very nature of a beta/Early Access title, many new ideas, systems, and additions will eventually make it into Wayward. As this is the case, we cannot guarantee your Workshop submission will continue to work indefinitely, nor cannot guarantee that your submission will always be necessary as we may build certain features/functionality/content into the game directly.

Our "todo" and idea list is huge and it's likely many ideas are already planned for Wayward or were submitted to us previously. If we have in fact taken direct inspiration from your idea/submission, we will always contact you beforehand. The community and player-base has always delivered us great ideas. Steam Workshop allows for those ideas to become reality faster than they would otherwise appear in the game by us.

That being said, we hope this does not hinder you from making Wayward into whatever you want and sharing your creativity with the community.

Have fun!

Generated using TypeDoc