I have been experimenting with the P5JS library.  P5JS is an open source JavaScript library for creative coding.  It can be found here:

P5JS provides easy to use functions for graphics, sound and user input.

P5JS Harmonic Motion

The Nature of Code

I have been working through The Nature of Code by Daniel Shiffman. It provides a great introduction to techniques for real-time simulations and animations. The full text of the book is available for free here:


The author hosts a YouTube channel with an enormous amount of educational content for creative coding:


Here’s a randomly selected video I found interesting:

In fact it inspired me to make my own image:


Collatz Conjecture Context Free Art

My JavaScript Sketchbook

I have been collecting the JavaScript sketches that I have made here:


Sketches are quickly hacked together projects to learn a technique or library. It’s a lot of fun to work on small projects like these and some of the have turned out to be rather fun to play with as well.

This video shows a sketch I made exploring Simple Harmonic Motion.

P5JS Harmonic Motion

There are lots of fun JavaScript libraries I am eager to play with. E.g.

There are lots of exciting things to explore with JavaScript.

Learning Web Assembly #2

Another milestone in my journey to learn Web Assembly has been achieved. I have created a cellular automata that runs in real time within the browser:

Try it yourself here:


Source code can be found in this repository:


Goals for Next Time:

For my next project in the series I would like to:

  • Use multiple threads.
  • Use ’embind’ to link the C methods to javascript as opposed to writing all the helper functions by hand.
  • Improve the user interface.

Learning Web Assembly

Web Assembly is a technology that allows code to be compiled to a portable byte code that can be run at near-native performance.

Web Assembly modules can be run by modern browsers and called from within the Javascript of a normal web page.

This offers the tantalizing prospect of creating high-performance code for games that can run on multiple platforms without the need for the user to download or install any ‘apps’.

Mandelbrot Web Assembly

A view from within the Mandelbrot Set

The first full project I have completed using Web Assembly in the browser is a Mandelbrot Fractal Explorer.

This was a good project to learn Web Assembly as it involves a looping procedure that can require many thousands of iterations.

The Mandelbrot Set is implemented in C with a function that can be called from Javascript. There is no shared state between any of the function calls.

You can try the Mandelbrot Explorer here:


The source code is available here – in a repository I’m using to collect the projects I use to learn how to use Web Assembly:


Future Learning

The next project I try with Web Assembly will be a Cellular Automata. This will let me try something with a persistent state inside the Web-Assembly module.

I’d like to try using PixiJS as a renderer to see if it’s possible to speed up the access to the pixel buffer.

The GUI for the Mandelbrot explorer was hacked together in a few days using native Javascript. It is a bit of a pain to keep a DOM form full of data in sync with the data being used to render the image so I may try using a framework such as VueJS for this purpose.

Learning how to render the Mandelbrot set is a lot of fun and it is addictive to mess with the colours and improve performance. I ultimately decided on a limited set of features just to get the project complete as my main goal was to learn Web Assembly – not make the perfect Mandelbrot renderer.

A gallery of screenshots taken during the development process can be found here:

Get Lamp

Interactive Fiction on Twitter

I put together a twitter bot that lets you play classic Text Based Adventures through twitter. The bot runs a game on a Raspberry Pi and tweets the console output from the game. Periodically the bot checks its mentions for tweets containing commands and sends those to the game.

The bot’s twitter feed can be found here:


The source code for the bot can be found here:


I made the bot after watching an interesting documentary on the history of Interactive Fiction:

The project served as a good distraction from burnout on my other project – virtual reality snake. In that project I have been using Test Driven Development fairly heavily with the goal of having complete test coverage. It’s slow going and I reached a breaking point when I went to shuffle a list in JavaScript and found that I would have to write my own shuffle function. I didn’t really feel like writing a Fischer-Yates shuffle for the millionth time

Making a project using Python was a nice change of pace since it includes most of those little functions you often find yourself needing.

The twitter bot also served as a good opportunity to make a project using Docker. Containerization on Linux is a new concept to me and I have to say I’m completely blown away by it. It solves a lot of the problems I was having with Python in the past – chiefly: packaging Python programs for other people to use.

Repeat Fractal

I put a gallery of fractals I made here:

Looking for underground bunkers to rent…

The future is made of virtual reality. Soon there will be no sound apart from the occasional thwacking of controllers hitting furniture.

WebVR with Babylon JS

Babylon JS is a 3D graphics library targeting HTML Canvas with WebGL. It includes support for WebVR and with relatively minimal setup you can get the controllers working in a simple VR space:

WRM Controller in BabylonJS

WRM Controller in BabylonJS

That’s a screen shot I took from within a virtual reality session running inside a web browser!

I’m working on a simple game of Simon Says to test the VR waters. You can follow the progress in the repository here:


The main goal of the project is to create a ‘base game’ that can be adapted to future projects. Learning the Babyon library is great. It astounds me that you can get high quality 3D graphics out of a web browser without needing to download any additional plug-ins.

Smell You Later Cell-u-later…

My work with Cellular Automata with Python hit a brick wall.

I was using Cython to run the expensive inner loops with C. This gave great run-time speeds.

Unfortunately I was unable to package the code so that it could be easily downloaded from repositories. After editing what seemed like a thousand config files I was burnt out.

I am still interested in using cellular automata to create a game similation. I hope to try and get something running in future using Web Assembly. It has the promise of C-like speed with the ease of distribution of a website that runs in the browser.

Devlog – Gift-wrapped Python

Cellular Automata with Python

I am interested in exploring game design focused around simulating a game world using Cellular Automata.

Conway's Game of Life

Conway’s Game of Life

Using Python I have implemented Conway’s Game of Life. The code for the project can be found in this Git Hub repository:


The code is still quite rough around the edges with plenty of TODO statements to be found.

Creating a Python Packagae

Usually I would dump my code in a folder and call it a day but for this project I decided to try and follow standard Python practice as much as possible.

This talk from Dave Forgac was a great resource:

The process of using Virtual Environments, Cookie Cutter and Tox integration testing tools was well explained.

I ran into some difficulty getting my Cython code to build correctly as this was outside the scope of the video.

After some searching I found the solution was to update the manifest file to include the code:



The Autumn CA package provides Cellular Automata computing through NumPy arrays.

Other tools such as rendering engines could import this package.

Most of the work in the short term will be ensuring the code works as a standard Python package.

Devlog – Cellular Automata

Simulating the Universe

Cellular Automata could provide interesting results for the simulation of video game worlds.

Systems using this model are described by a regular grid of cells with a numerical state. During the simulation each cell decides its next state by applying a rule function to the cells next to it.

An example of such a system is Conway’s Game of Life. This famous Cellular Automaton shows how incredible complexity can arise from a system with simple rules.

All of the cells change their state at the same time using the data from the last state. This is interesting because it means Cellular Automata could benefit from parallel processing from multi-core CPUs, GPUs and perhaps even Quantum Computing.

Besides simulating the universe Cellular Automata can be used to make psychedelic ‘living paintings’:

Creating my own CA with Python

I have made some progress in creating my own Cellular Automata using Python:

Game Of Life - Python

Conway’s game of life running in Python. Rendered using Pygame.

The first iteration can run a 100×100 simulation at around 13 frames per second. Python’s lists were used for the data structure so the performance is not great.

Now that I have the basic structure of the program and benchmarking system I am working on making a faster version using the NumPy library. It provides access to fast arrays implemented in C so it should be possible to make the simulation much faster.

Unfortunately the process of speeding up the program is more involved than putting ‘import numpy’ at the top of the file. This is my first time trying to use NumPy Arrays and it is an interesting learning process!

DevLog: One Step Forwards – Two Steps Back

The development of the Flower Plower prototype is currently on pause.

Flower Plower started 5 months ago with the hopes of making a ‘quick prototype’ that would give me a chance to develop my tools and frameworks so that future games could be prototyped more quickly.

The overall design of the game was not completely solid. I had some vague ideas of how things would work but changed my mind as things progressed. The design of the project changed from Pacman to Chu Chu Rocket.

While I still really like the idea for Flower Plower as a simulation puzzle the process of converting the code from how it was designed for a maze running arcade game to a puzzle game is getting in the way of the initial goal for the game: Optimize my Unity Workflow

The work I have done so far on Flower Plower was by no means a waste of time as I was focusing on code that I can re-use for any game.

I have taken the code that I developed for Flower Plower and re-purposed it for a new game. Now I can focus on building my tools and solving the problems relevant to many games rather than refactoring classes and staring at compiler warnings.

The idea for the new game is kinda dumb so I’m really excited to work on it!

Devlog – Discretion Required

Booming flower prices promise great rewards for the fastest Flower Plower!

Initially Flower Plower was conceived as a Pacman style maze running game.

The design of that game called for a continuous movement grid. Objects on the grid can move smoothly between grid cells but are only allowed to turn when they are in the center of a grid space.

Objects have two variables controlling their direction. Current Direction and Desired Direction. If the object wants to change its direction it sets the Desired Direction variable.

When the object reaches the center of a grid space it checks if the Current Direction is equal to Desired Direction and tries to turn if not. If a wall is blocking the turn the Current Direction remains the same until it is possible to turn.

This system allows the player to hold the direction they want to turn early and their character will turn when it is possible.

Continuous Grid Turn

Objects move continuously and are only allowed to turn in the center of a grid node.

One added complexity is allowing 180 degree turns in between tiles. It might feel better to allow players to turn slightly late and move back to perform a turn – just a slightly wider window of opportunity.

This system works well for a Pacman style maze runner but now that my prototype is heading in a simulation puzzle direction I have decided to use a discrete grid.

A discrete grid uses arrays of integers for positions rather than Unity vector3s with float values. This means that an object can not be between two grid locations.

This approach has brought with it a lot of additional complexity but I am starting to see the light at the end of the tunnel! So hopefully there will be more details in a future post.

Devlog – Fine by Design

Coordinate the chaos of flower farming during boom times. Become the ultimate Flower Plower

The Limitations of the Design

The initial plan for the game was something similar to Pac Man where you plant seeds and grow flowers.

As development progressed important questions such as ‘What should the player do?’ and ‘What makes the game fun?’ were mostly answered by hand waving.

The rough idea is that the player would plant flowers in the paths between fields. The fields would be filled with sheep who would periodically move from one field to another blocking the paths. As the game progressed the player would expand their network of fields and paths so the strategy would be to create paths that would be good for farming big combos from the flowers while still having enough branches to avoid the sheep.

On the surface it sounds great but when trying to make the ideas more concrete it becomes more difficult to find the fun. Flocks of sheep that block the maze as the main obstacle isn’t great and while the idea that the player creates their own maze is cool the mazes would ultimately be a little dull. After creating your own 4 directional maze you will still end up with a simple maze – it’s hard to see where there’s much room for excitement.

Simulation Puzzle

So the new idea is something of a Simulation Puzzle.

The player places signals on the farm that control the movement of tractors. The tractors pull trailers that will perform actions such as planting seeds and harvesting flowers. The game will reward getting things done as fast as possible and their will be an emphasis on timing actions so that they occur simultaneously.

The main influences on the design currently would be the Dreamcast classic Chu Chu Rocket and a great construction sim called Factorio. There should be plenty of potential fun to be found from setting a farm up, watching it run and trying to improve the amount of flowers you can produce.

Implementation Progress

A focus of the implementation strategy is to reduce coupling between components so that the game objects can be repurposed without throwing out all the code. Happily the plan is working and good progress is being made.

The new design does have the requirement that objects should move across the grid in a predictable fashion.

Objects move continuously through the grid using floating point numbers to represent their current position. The downside to this is that if you move two objects the same distance at the same speed they may arrive on different frames.

This indeterminism is caused by inaccuracies that can result from rounding floating point numbers. Long numbers can’t be represented exactly by a 32-bit number so over time mistakes will creep in.

I have dealt with this problem before when trying to make an action replay system for Jet The Pack and my solution then was to just scrap the replay system. It’s very hard to get the Unity physics engine to do the same thing twice.

For this game I plan to update the objects that move on the grid so that logically they are only ever in the center of a tile. They can move periodically using a tick sent through the event system and the meshes that provide their graphics on-screen can be moved over time using linear interpolation.