Indie game storeFree gamesFun gamesHorror games
Game developmentAssetsComics
A jam submission

Sibyl - The Procedural Level PainterView project page

Turn your tiles into countless levels.
Submitted by Neverdusk — 32 minutes, 23 seconds before the deadline
Add to collection

Play tool

Sibyl - The Procedural Level Painter's page


CriteriaRankScore*Raw Score
How original or innovative it is#54.1004.100
How much I could potentially use it in the future#193.4003.400
How nice it is to use#363.5003.500

Ranked from 10 ratings. Score is adjusted from raw score by the median number of ratings per game in the jam.

Leave a comment

Log in with to leave a comment.



For big dungeons, this might be a god send.


Thank you for trying it! 


Awesome tool, could create some vampire survivor like levels really fast :)


Thank you, I'm glad you liked it!


Pretty cool. Couldn't you just generalize the WFC algorithm to elements larger than 1 pixel? Or is that basically what you're doing?


I am doing something similar, at least on the surface, though it's very different from how WFC is usually implemented. 

WFC's tile-based mode can't analyze textures by itself and needs JSON to know the rules between everything. However, its pixel-based mode can analyze textures but only places pixels in overlapping patterns it recognizes, with no regard for distance or adjacency. Even if you stretch the pixel-based mode to be larger, it'll still have some strange results. 

Sibyl's algorithm was initially inspired by the tile-based approach. But it scans and recognizes tiles in order to automatically create its own rules for each them. In practice, this requires a lot of different changes to how the algorithm even works, to the point where it's become it's own thing. The closest thing I've found to Sibyl's algorithm is something called a Markov Chain-based Wave Function Collapse, but that works very differently on the inside, and it still requires some manual JSON.

The largest difference between MkWFC and Sibyl is that Sibyl also considers probability, based on the template it's provided. So instead of simply placing compatible tiles, it places them according to the frequency in which your template uses them. So if your template has a ton of grass, a moderate amount of water, and a flower that only sometimes appears - Sibyl's outputs will tend to have similar results. This allows it to create levels that feel handcrafted, because it actually studies how the templates you provide are crafted.


OK, yeah I think I understand now. Thanks!

I would think putting "Markov Chain" in the name implies some amount of probability, but maybe that's why I'm not in charge of naming things.


At least to my understanding, the Markov Chain variant uses randomness (like regular WFC) but it doesn't use weighted decisions. So it asks "what could go here" while Sibyl asks "what would best fit here". 

All that said, WFC and MkWFC are still very good algorithms. Most importantly, they're naturally faster, so they can be used in games for real-time generation, while Sibyl sacrifices some speed for control and quality. I am still working to optimize Sibyl, but it does have a higher workload to contend with.


This is really awesome, it creates really cool levels and I really like the fact you can delete or change a specific part.

Unfortunately I didn't have a template to import so I used the existing ones, but I will try it again in the future when I have something.

Could you share a bit about how it learns to create the level according to the template?


Thank you for trying it out!

The program was initially inspired by an algorithm called Wave Function Collapse (, which can take a texture and output similar results. The issue with WFC, for me, is that it can only analyze individual pixels on its own, and anything involving tiles requires a time-consuming process of using JSON to manually teach it tile-by-tile relationships.

What Sibyl does is tie both halves together - pixel analysis and tile relationships - so it can automatically read any tilemap and output similar results, all by itself. The first step involves scanning the provided template, recognizing identical tiles, and recording what tiles they're paired with (making them compatible neighbors) in each direction. In the second step, it uses a WFC-like algorithm to place tiles across the level, while attempting to only place compatible neighbors next to each other. 

Moreover, Sibyl also considers how often neighboring combinations are present in the template you provide. This allows it to try to replicate the design of the template itself, rather than simply randomly placing whatever tiles work together. 

As a result, Sibyl can autonomously create levels that also feel handmade, by simply providing it with an example level. However, a carefully-crafted template can provide even more flexible and controlled results, for whoever is willing to spend the time on making one. The Making Templates guide goes through some of the different best practices I've figured out in regards to that. 


Thanks a lot for the detailed response!

This algorithm is cool, I enjoyed reading about it :)


Be sure to check out the game page to learn how to make the most of Sibyl. Enjoy!