Announcing PUZZLON (even though it's been low-key available for years)

Puzzlon is a dependency chart (+ game solution visualisation) creation tool, hosted in the browser.

I sat on the release for quite some time as I didn’t have time to document it to a high standard, so let autocompletion and the in-built sample be your guide. For autocomplete, press Control + Space on blank lines and between [ ] .

This system previously existed as “Vizon” (also written by myself), but this new version has more features and a modified syntax.

I’m sure most people here are aware of Puzzle Dependency Charts, but if you are not, they are useful for planning out puzzle trees for IF / Text Adventures / Graphic Adventures, pretty much anything with dependent puzzles.

A very linear game will have almost a straight line from top to bottom (or left to right) describing actions the player should perform in order to progress. Any time the player gets stuck, it ends all forward momentum and the player is likely to get frustrated and stop playing the game.

Fun games tend to have multiple things that player can be working on / solving at the same time, and that takes the form of a girthy diagram, where all puzzles are working towards a common goal, whether that be the end of the game or the end of an “act” or chapter.

For more information on PDC, read Ron Gilbert’s blog on Puzzle Dependency Charts here.

Here is an example SVG that was generated using Puzzlon (spoilers for TWO):


Emily Short wrote an essay about her use of puzzle graphs:

It’s worth a read.


This looks really cool! I’ll have mess with it when I’m on my desktop.

Sadly, it’s pretty much unusable on mobile right now. Attempting to type anything zooms in to this incredibly readable size:


Sorry about the lack of mobile editor. That’s not going to change any time soon unfortunately, so it remains a desktop-only tool for the foreseeable.

Aww. That’s too bad. It seems like it’d work quite well, other than the zooming issue. Dragging the map around works fine as well.

This is how it looks before I click the text area:


This is a fantastic tool! I finally got around to trying it out last night, and it’s shown me visually what I already suspected, that the puzzle pathways in my latest parser game are rather unbalanced.

What’s the syntax for creating the black end-of-game diamond? Now that I’d deleted the example game in my browser, I have nothing to refer to.

It would be great to be able to save multiple different games in a future release.


Looks like it’s a : goal instead of a : action? Also, you might be able to have a look at the example by opening the page in a private browsing window (Ctrl-Shift-N in Chrome/Edge, Ctrl-Shift-P in Firefox). That’ll act like a separate new user that’s not connected to your existing session.


At the moment, the terminal condition is a goal with “end_state” attribute specified.

Maybe I’ll introduce a terminal type later on.

   end_of_game_diamond : goal {
      depends_on = [ gain_access_to_mansion ]
      // Choose one of the following
      end_state  = positive | negative | neutral

This is an interesting tool, still would love some documentation on this someday. Is OR and AND the only supported logic gate types? In one of my WIPs I’ve tried creating a chart for, I’ve found a puzzle with an XOR dependency, or maybe a three-way branch. I’m not certain if I’ll need to create a condition to try to create the logic. I might be trying to flowchart the puzzle, instead of showing its dependencies. Doing A or B dependency will change what happens during this puzzle. Doing both will unlock a shortcut option that can easily bypass this puzzle.

It will be interesting to see what the chart looks like as I progress.

No XOR logic gate right now.

Thinking about the description of your problem, I might model it like this:

: diagram  { 
   events {
      achieved_a       : condition;
      achieved_a_and_b : condition;
      achieved_a_b_goal : goal {
         depends_on = [perform_a, perform_b]
         logic_gate_type = or
      achieved_b       : condition;
      final_goal : goal {
         depends_on = [some_downstream_action_5]
         end_state = positive
      perform_a : action ;
      perform_b : action;
      some_downstream_action_1 : action {
         depends_on = [achieved_a_b_goal, achieved_a]
      some_downstream_action_2 : action {
         depends_on = [achieved_a_b_goal, achieved_b]
      some_downstream_action_3 : action {
         depends_on = [achieved_a_b_goal, achieved_a_and_b]
      some_downstream_action_4 : action {
         depends_on = [some_downstream_action_1, some_downstream_action_2, some_downstream_action_3]
         logic_gate_type = or
      some_downstream_action_5 : action {
         depends_on = [some_downstream_action_4, some_downstream_action_3]
         logic_gate_type = or