Convert Figma logo to code with AI

Mindwerks logoworldengine

World generator using simulation of plates, rain shadow, erosion, etc.

1,002
129
1,002
60
View on GitHub

Top Related Projects

Azgaar's avatar

Fantasy-Map-Generator

4,841

Web application generating interactive and highly customizable maps

rlguy's avatar

Blender-FLIP-Fluids

1,735

The FLIP Fluids addon is a tool that helps you set up, run, and render high quality liquid fluid effects all within Blender, the free and open source 3D creation suite.

mewo2's avatar

terrain

3,034

Fantasy map generator

fogleman's avatar

Craft

10,597

A simple Minecraft clone written in C using modern OpenGL (shaders).

Quick Overview

WorldEngine is an open-source world generation tool that creates realistic and customizable fantasy maps. It uses scientific principles to simulate plate tectonics, erosion, and climate patterns, producing detailed and diverse landscapes for use in games, writing, or worldbuilding projects.

Pros

  • Scientifically-based world generation for realistic and believable landscapes
  • Highly customizable parameters for creating diverse world types
  • Exports maps in various formats, including images and heightmaps
  • Active community and ongoing development

Cons

  • Steep learning curve for advanced customization
  • Resource-intensive for generating large or highly detailed worlds
  • Limited documentation for some features
  • Occasional bugs and stability issues

Code Examples

  1. Generate a basic world:
from worldengine import World, Step

world = World.from_seed(seed=42, width=512, height=512)
world.generate(Step.full())
world.export_image("my_world.png")
  1. Customize world generation parameters:
from worldengine import World, Step, BiomeType

world = World.from_seed(seed=42, width=512, height=512)
world.set_ocean_level(0.65)
world.set_temperature_range(-10, 35)
world.generate(Step.full())
world.set_biome(BiomeType.JUNGLE, percentage=0.3)
world.export_image("custom_world.png")
  1. Generate and export heightmap:
from worldengine import World, Step

world = World.from_seed(seed=42, width=512, height=512)
world.generate(Step.full())
world.export_heightmap("world_heightmap.png")

Getting Started

  1. Install WorldEngine:
pip install worldengine
  1. Generate a basic world:
from worldengine import World, Step

world = World.from_seed(seed=42, width=512, height=512)
world.generate(Step.full())
world.export_image("my_first_world.png")
  1. Explore the generated world image and experiment with different parameters to create unique landscapes.

Competitor Comparisons

Azgaar logo

Fantasy-Map-Generator

4,841

Web application generating interactive and highly customizable maps

Pros of Fantasy-Map-Generator

  • More user-friendly interface with interactive map editing
  • Generates a wider variety of map elements (cities, states, religions, etc.)
  • Actively maintained with frequent updates

Cons of Fantasy-Map-Generator

  • Less focus on scientific accuracy in world generation
  • Limited customization options for underlying terrain generation algorithms

Code Comparison

Fantasy-Map-Generator (JavaScript):

function generateTerrain() {
  const cells = pack.cells;
  cells.h = new Uint16Array(cells.i.length);
  const N = cells.h.length;
  const regionCells = [...new Set(cells.region)].map(r => cells.i.filter(i => cells.region[i] === r));
  // ... (additional code)
}

Worldengine (Python):

def generate_world(seed, width, height, num_plates=10):
    world = World(seed, width, height, num_plates)
    world.generate_plates()
    world.generate_elevation()
    world.generate_ocean()
    # ... (additional code)

The code snippets show different approaches to terrain generation. Fantasy-Map-Generator uses JavaScript and focuses on cell-based generation, while Worldengine uses Python and employs a more structured, step-by-step world creation process.

rlguy logo

Blender-FLIP-Fluids

1,735

The FLIP Fluids addon is a tool that helps you set up, run, and render high quality liquid fluid effects all within Blender, the free and open source 3D creation suite.

Pros of Blender-FLIP-Fluids

  • Specialized for fluid simulations in Blender, offering high-quality liquid effects
  • Actively maintained with frequent updates and bug fixes
  • Extensive documentation and user guides available

Cons of Blender-FLIP-Fluids

  • Limited to fluid simulations, not suitable for general world generation
  • Requires Blender as a dependency, limiting its use in other environments
  • Steeper learning curve for non-Blender users

Code Comparison

Worldengine (Python):

world = World.from_elevation_map(filename, resize_factor)
world.set_ocean_level(1.0)
world.precipitations_simulation()
world.erosion()

Blender-FLIP-Fluids (Python API):

bpy.ops.flip_fluid_operators.add_domain()
domain = bpy.context.scene.objects.active
domain.flip_fluid.domain.resolution = 100
domain.flip_fluid.domain.simulation_method = 'FLIP'
bpy.ops.flip_fluid_operators.add_fluid_object()

The code snippets demonstrate the different focus areas of each project. Worldengine is geared towards world generation and geological processes, while Blender-FLIP-Fluids is specifically designed for fluid simulations within Blender.

mewo2 logo

terrain

3,034

Fantasy map generator

Pros of terrain

  • More focused on generating visually appealing maps
  • Simpler and more lightweight implementation
  • Easier to integrate into web-based projects

Cons of terrain

  • Less comprehensive world generation features
  • Limited customization options for terrain types
  • Lacks advanced features like climate simulation

Code comparison

terrain:

function generateHeightmap(width, height) {
  const heightmap = new Array(width * height);
  // ... (simplified height generation logic)
  return heightmap;
}

worldengine:

def generate_world(seed, width, height):
    world = World(seed, width, height)
    world.set_elevation(...)
    world.set_ocean_level(...)
    world.set_precipitation(...)
    return world

The terrain project focuses on generating simple heightmaps using JavaScript, making it suitable for web-based map generation. In contrast, worldengine uses Python to create more complex world models with multiple layers of data, including elevation, precipitation, and ocean levels.

worldengine offers a more comprehensive approach to world generation, including features like plate tectonics simulation and biome classification. However, this comes at the cost of increased complexity and potentially slower generation times.

terrain is better suited for projects that require quick, visually appealing map generation, while worldengine is more appropriate for applications needing detailed, scientifically-based world models.

fogleman logo

Craft

10,597

A simple Minecraft clone written in C using modern OpenGL (shaders).

Pros of Craft

  • Simple and lightweight voxel-based game engine
  • Easy to understand and modify codebase
  • Cross-platform support (Windows, macOS, Linux)

Cons of Craft

  • Limited world generation capabilities
  • Fewer features compared to more complex world generation tools
  • Less focus on realistic terrain and biome creation

Code Comparison

Craft (main game loop):

int main(int argc, char **argv) {
    // ...
    while (1) {
        glfwPollEvents();
        handle_movement(dt);
        render();
        // ...
    }
    // ...
}

WorldEngine (world generation):

def generate_world(seed, width, height):
    # ...
    world = World(seed, width, height)
    world.set_elevation(elevation)
    world.set_ocean_level(ocean_level)
    world.set_precipitation(precipitation)
    # ...
    return world

WorldEngine focuses on complex world generation with realistic terrain, while Craft provides a simpler voxel-based game engine. WorldEngine offers more advanced features for creating detailed worlds, but Craft excels in its simplicity and ease of use for basic voxel game development. The code comparison highlights the different approaches: Craft's main loop for game rendering and WorldEngine's world generation process.

Convert Figma logo designs to code with AI

Visual Copilot

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

WorldEngine - a world generator

Build Status Build status Coverage Status Code Health codecov.io Coverage Status Coverage Status Requirements Status

The current stable version is 0.19.0

You can generate the data for your own world, including a number of images (heightmap, biomes, etc.).

For example:

worldengine world -s 1 -n seed1

Worlds are generated using plate simulations, erosion, rain shadows, Holdridge life zones model and plenty of other phenomenons.

The created world can be used for simulating the evolution of a civilization (see project civs).

It is also possible to generate additional maps, for example an ancient looking map:

worldengine ancient_map -w seed1.world

We started a Google group: Should you have ideas, problems, suggestions or want to contribute, please join us!

Manual

The Manual for Worldengine : http://worldengine.readthedocs.io/en/latest/

Interoperability (Python, Java)

We would love to see WorldEngine used together with other tools. Worlds generated by WorldEngine can be loaded into python applications using WorldEngine itself as a library. Java applications can instead use WorldEngine-Java, a java library to load WorldEngine files.

Worlds can be saved using the protobuf format or hdf5, for which there are libraries in several languages. We keep working on supporting more formats and always interested in ways to improve interoperability.

Binary packages

For Windows, Linux and Mac are available on the releases page.

Gui

An experimental (and limited!) GUI is available as a separate project: https://github.com/Mindwerks/worldengine-gui.

Install

Using Docker

First, git clone or download the code, then:

bin/run_in_docker.sh

Using pip

# Currently not yet released on pypi, you may want to still use Lands or WorldSynth
# or alternatively download the source
pip install worldengine

From source code

git clone or download the code

# for unit-testing: also clone worldengine-data
git clone git@github.com:Mindwerks/worldengine-data.git ../worldengine-data
nosetest tests

On Windows

If you want to install Worldengine on Windows you can read these instructions.

Executable file is also available under releases, but is currently out of date.

Note: you need also a copy of the worldengine src directory in the same folder as the exe.

Dependencies

The gui is based on QT, so you will need to install them

Output

The program produces a binary format with all the data of the generated world and a set of images. For examples seed 1 produces.

Elevation Map

Precipitation Map

Temperature Map

Biome Map

Ocean Map

There are several optional outputs and many options to control the result. The manual is your friend!

Usage

worldengine [options] [world|plates|ancient_map|info]

For details about all the possible options please refer to the manual.

For example these commands:

worldengine -s 4 -n an_example -q 25 -x 2048 -y 2048

Produce this output

Worldengine - a world generator (v. 0.19.0)
-----------------------
 operation            : world generation
 seed                 : 4
 name                 : an_example
 width                : 2048
 height               : 2048
 number of plates     : 25
 world format         : protobuf
 black and white maps : False
 step                 : full
 greyscale heightmap  : False
 rivers map           : False
 scatter plot         : False
 fade borders         : True

starting (it could take a few minutes) ...

Producing ouput:
* world data saved in './an_example.world'
* ocean image generated in './an_example_ocean.png'
* precipitation image generated in './an_example_precipitation.png'
* temperature image generated in './an_example_temperature.png'
* biome image generated in './an_example_biome.png'
* elevation image generated in './an_example_elevation.png'
...done

This is the corresponding ancient map

worldengine ancient_map -w an_example.world

Algorithm

The world generation algorithm goes through different phases:

  • plates simulation: it is the best way to get proper mountain chains. For this pyplatec is used
  • noise techniques are used at different steps
  • precipitations are calculated considering latitude and rain shadow effects
  • erosion is calculated
  • humidity in each zone is calculated
  • terrain permeability is calculated
  • biome is calculated using the Holdridge life zones model

Development

Using virtualenv you can create a sandbox in which to develop.

Python 2

virtualenv venv
source venv/bin/activate
pip install --upgrade pip setuptools
pip install -r requirements-dev.txt
python worldengine

Python 3

virtualenv venv -p /usr/bin/python3
source venv/bin/activate
pip install --upgrade pip setuptools
pip install -r requirements-dev.txt
python worldengine

Distribution

We use PyInstaller to wrap everything up into one binary.

This will create a binary located dist/worldengine that has all the required libs necessary to run.

Linux

Because of the libraries we use, it is best to use their develop branch.

pip install git+https://github.com/pyinstaller/pyinstaller.git@develop
pyinstaller --clean -F -n worldengine worldengine/__main__.py

OSX

You'll need to have brew installed, this should give you all the tools you'll need.

pyinstaller --clean -F -n worldengine worldengine/__main__.py

At this time, it doesn't gather everything from protobuf. So you'll need to copy google/protobuf python to dist/google/protobuf and create init.py in dist/google

Windows

Turning your Windows into a developer environment is a long and drawn out process. I'll try to keep this as short as possible and to the point.

Remember, be consistent if you are either win32 or win64 and everything you download and install is either one or the other, but not both.

You'll want to install msysgit: https://msysgit.github.io/ which will get you a Linux like environment. After that, clone the repo and install Python 2.7 for windows: https://www.python.org/downloads/windows/ This will get you also pip which is required for the rest. You'll first need to pip install virtualenv.

The layout is a bit different than in Linux.

virtualenv venv
venv/Scripts/pip install -r requirements.txt

Numpy install will fail, so you'll need download a pre-compiled wheel file and install it with pip. http://www.lfd.uci.edu/~gohlke/pythonlibs/#numpy numpy‑1.9.2+mkl‑cp27‑none‑win_amd64.whl Pick one for your arch, 32 or 64.

venv/Scripts/pip install ../numpy‑1.9.2+mkl‑cp27‑none‑win_amd64.whl

Next step is to get pywin32 which are win32api hooks for python, when downloading, you'll need to pick either 32 or 64-bit otherwise it won't work. You'll also install it via pip. http://sourceforge.net/projects/pywin32/files/pywin32/

venv/Scripts/pip install ../pywin32-219.win-amd64-py2.7.exe

The last step is to get pyinstaller installed and this can be tricky because as of right now, we have to use a specific revision that "good-enough". The issue is being tracked here: https://github.com/pyinstaller/pyinstaller/issues/1291

venv/Scripts/pip install git+https://github.com/pyinstaller/pyinstaller.git@67610f2
venv/Scripts/pyinstaller --clean --console -F -n worldengine worldengine/__main__.py

Do you have problems or suggestions for improvements?

Please write to us! You can write us at:

  • f dot tomassetti at gmail dot com
  • psi29a at gmail dot com Thank you, all the feedback is precious for us!

Projects using WorldEngine

WorldEngine is being used in several products and we are starting to list them here:

If you are using WorldEngine please let us know!

Contributors

This project is maintained by Bret Curtis and Federico Tomassetti.

All contributions, questions, ideas are more than welcome! Feel free to open an issue or write in our google group.

We would like to thank you great people who helped us while working on WorldEngine and the projects from which it was derived:

  • Evan Sampson contributed the amazing implementation of the Holdridge life zones model and improved a lot the ancient-looking-map, biome, precipitation and temperature generators. Thanks a million!

  • Ryan contributed the Windows binary version and discussed Lands on Reddit bringing a lot of users. Thanks a million!

  • stefan-feltmann made Lands depends on pillow instead that on PIL (which is deprecated). This could also help when moving to Python 3. Thanks a million!

  • Russell Brinkmann helped saving the generation parameters in the generated world (so that we can use it to generate the same world again, for example), improved the command line options and added tracing information (useful for understanding the performance of the various generation steps)

  • Joshua Coppola implemented the satellite view. Thanks a lot, it looks gorgeous!

  • Stephan made WorldEngine make heavy use of numpy, helping to speed up the generation. He also made world-generation much more reproducible and helped improve compatibility with Python 3.

  • Alex made things generally run faster and look cleaner by better employing numpy.

History

WorldEngine has been created by merging Lands and WorldSynth. Last Lands version was 0.5.3, last WorldSynth version: 0.12, first WorldEngine version has been 0.18.

License

WorldEngine is available under the MIT License. You should find the LICENSE in the root of the project.