ConwayLife.com

• Pattern selection: Add a selection tool that lets you select rectangular portions of the grid, which the user can then manipulate. (Rotate, flip, nudge, copy, save, etc.) (Side note: Something I've always wanted in Golly is polygonal selection, but that might be a stretch.)
• Speed control: More precise simulation speed control, since the current one is a bit hard to understand. Might be useful to add more info at the top.
• Reset: Add a 'reset' button which allows the user to return to generation 0.
• Copy+paste RLE: Allow copying, cutting and pasting of patterns. Patterns can be stored as text using Run Length Encoded (RLE) format. This is very useful, and most other platforms support it, so the user would be able to copy and paste things across different simulators.
• Import/download patterns: Import pattern files that are in RLE (.rle) (or macrocell, .mc) format and download patterns as files.
• OCA support: Support OCAs (other cellular automata) and not just Conway's Game of Life. This could be done by adding a feature where the user could input a rulestring to specify the rule.
• Help window: Add a 'help' popup that explains things about the simulator and how to use it and things like keyboard shortcuts.

I6_I6 wrote: February 17th, 2026, 5:11 pm Also, I'm not entirely sure why there are separate Hashlife and 'normal' algorithms when you can just use Hashlife. The patterns will still evolve the same, but Hashlife would be faster (assuming normal mode is just calculating the neighbors of live cells without hashing).

hotdogPi wrote: February 17th, 2026, 7:42 pm HashLife isn't always faster. It's slower when running my search program or my oscillator stamp collection, for example.

#N fireworks.rle
#O John Elliott
#C An admirably beautiful rule. Sample starting pattern.
#C
#C From Mirek Wojtowicz's 'MCell 4.20' pattern collection:
#C http://www.mirekw.com/ca/download.html
#C Original filename for MCell-format file:  Fireworks.mcl
#C Converted to Golly native RLE format as per discussion in
#C https://conwaylife.com/forums/viewtopic.php?p=139226#p139226
x = 108, y = 100, rule = 2/13/21:T400
88.A6$A58$61.A24$107.A11$37.A!

rowett wrote: February 18th, 2026, 3:34 pm

hotdogPi wrote: February 17th, 2026, 7:42 pm HashLife isn't always faster. It's slower when running my search program or my oscillator stamp collection, for example.

HashLife is excellent at patterns containing repeated sets of cells. It's very poor when there's little or no repetition as the pattern evolves:

Code: Select all

#N fireworks.rle
#O John Elliott
#C An admirably beautiful rule. Sample starting pattern.
#C
#C From Mirek Wojtowicz's 'MCell 4.20' pattern collection:
#C http://www.mirekw.com/ca/download.html
#C Original filename for MCell-format file:  Fireworks.mcl
#C Converted to Golly native RLE format as per discussion in
#C https://conwaylife.com/forums/viewtopic.php?p=139226#p139226
x = 108, y = 100, rule = 2/13/21:T400
88.A6$A58$61.A24$107.A11$37.A!

This is a good example of a HashLife-unfriendly pattern. On my machine Golly (using HashLife) manages 74 generations per second. LifeViewer (using a sequential iterator) manages 831 generations per second, and LifeViewer Pro (using a SIMD accelerated sequential iterator) can do 5880 generations per second.

I6_I6 wrote: February 19th, 2026, 1:17 am How would I use an algorithm that iterates through the cells in Golly?

I6_I6 wrote: February 19th, 2026, 1:17 am Also, how can you check the generations per second in both Golly and LV?

-- Go to a requested generation.  The given generation can be an
-- absolute number like 1,000,000 (commas are optional) or a number
-- relative to the current generation like +9 or -6.  If the target
-- generation is less than the current generation then we go back
-- to the starting generation (normally 0) and advance to the target.
-- Authors: Andrew Trevorrow and Dave Greene, Mar 2024.

local g = golly()
local gp = require "gplus"
local validint = gp.validint

--------------------------------------------------------------------------------

local function intbase(n, b)
    -- convert integer n >= 0 to a base b digit array (thanks to PM 2Ring)
    digits = {}
    while n > 0 do
        digits[#digits + 1] = n % b
        n = math.floor(n / b)
    end
    if #digits == 0 then digits = {0} end
    return digits
end

--------------------------------------------------------------------------------

-- math.maxinteger is a 19-digit number on a 64-bit system, but we have to
-- limit gen counts to 16-digit numbers to avoid overflow problems
local maxdigits = #tostring(math.maxinteger) - 3

local function check_number(numstr)
    if #numstr > maxdigits then
        g.exit("Number is too large for Lua -- use goto.py instead.")
    end
    return tonumber(numstr)
end

--------------------------------------------------------------------------------

local function go_to(gen)
    local currgen = check_number(g.getgen())
    local newgen
    if gen:sub(1,1) == '+' then
        newgen = currgen + check_number(gen:sub(2,-1))
    elseif gen:sub(1,1) == '-' then
        local n = check_number(gen:sub(2,-1))
        if currgen > n then
            newgen = currgen - n
        else
            newgen = 0
        end
    else
        newgen = check_number(gen)
    end
    
    if newgen < currgen then
        -- try to go back to starting gen (not necessarily 0) and
        -- then forwards to newgen; note that reset() also restores
        -- algorithm and/or rule, so too bad if user changed those
        -- after the starting info was saved;
        -- first save current location and scale
        local midx, midy = g.getpos()
        local mag = g.getmag()
        g.reset()
        -- restore location and scale
        g.setpos(midx, midy)
        g.setmag(mag)
        -- current gen might be > 0 if user loaded a pattern file
        -- that set the gen count
        currgen = check_number(g.getgen())
        if newgen < currgen then
            g.error("Can't go back any further; pattern was saved "..
                    "at generation "..currgen..".")
            return
        end
    end
    if newgen == currgen then return end
    
    g.show("Hit escape to abort...")
    local oldsecs = os.clock()
    local starttime = oldsecs

    -- before stepping we advance by 1 generation, for two reasons:
    -- 1. if we're at the starting gen then the *current* step size
    --    will be saved (and restored upon Reset/Undo) rather than a
    --    possibly very large step size
    -- 2. it increases the chances the user will see updates and so
    --    get some idea of how long the script will take to finish
    --    (otherwise if the base is 10 and a gen like 1,000,000,000
    --    is given then only a single step() of 10^9 would be done)
    g.run(1)
    currgen = currgen + 1

    -- use fast stepping (thanks to PM 2Ring)
    for i, d in ipairs(intbase(newgen - currgen, g.getbase())) do
        if d > 0 then
            g.setstep(i-1)
            for j = 1, d do
                if g.empty() then
                    g.show("Pattern is empty.")
                    return
                end
                g.step()
                local newsecs = os.clock()
                if newsecs - oldsecs >= 1.0 then
                    -- do an update every sec
                    oldsecs = newsecs
                    g.update()
                end
            end
        end
    end
    local endtime = os.clock() - starttime
    local totalgens = newgen - currgen + 1

    g.note(totalgens.." gens in "..(math.floor(10 * endtime)/10).."s = "..math.floor(totalgens / endtime).."gps")
    g.show("")
end

--------------------------------------------------------------------------------

local function savegen(filename, gen)
    local f = io.open(filename, "w")
    if f then
        f:write(gen)
        f:close()
    else
        g.warn("Can't save gen in filename:\n"..filename)
    end
end

--------------------------------------------------------------------------------

-- use same file name as in goto.py
local GotoINIFileName = g.getdir("data").."goto.ini"
local previousgen = ""
local f = io.open(GotoINIFileName, "r")
if f then
    previousgen = f:read("*l") or ""
    f:close()
end

local gen = g.getstring("Enter the desired generation number,\n"..
                        "or -n/+n to go back/forwards by n:",
                        previousgen, "Go to generation")
if gen == "" then
    g.exit()
elseif gen == '+' or gen == '-' then
    -- clear the default
    savegen(GotoINIFileName, "")
elseif not validint(gen) then
    g.exit("Sorry, but \""..gen.."\" is not a valid integer.")
else
    -- best to save given gen now in case user aborts script
    savegen(GotoINIFileName, gen)
    local oldstep = g.getstep()
    go_to(gen:gsub(",",""))
    g.setstep(oldstep)
end

bryan.pauquette wrote: February 17th, 2026, 10:13 am If you have time, please test both links and share feedback

Uncaught TypeError: this.model.getSpeed is not a function
    at GameController.increaseSpeed (GameController.js:782:37)
    at GameController.handleKeyDown (GameController.js:741:14)
    at GameController.js:206:12
    at GameView.emit (GameView.js:53:11)
    at HTMLDocument.<anonymous> (GameView.js:404:12)

bryan.pauquette wrote: February 19th, 2026, 9:42 am Yes, it was a difficult balance between staying compliant with WCAG guidelines and making it fun. Most people who are not subject to flashing effects would like to turn it off but it can not be the default out of the box.

rowett wrote: February 21st, 2026, 1:34 pm [...]
I chose to just cap the cell grid rendering (rather than the generation rate) since with a low generation rate it's fairly useless. Also this just happens during playback.

muzik wrote: February 27th, 2026, 7:14 pm Having difficulty with loading the site. Is it down or just under stress?


You are correct sir. I did a windows update yesterday and it hosed up my 443 firewall inbound rules. Check again now.

https://www.youtube.com/watch?v=xDLvUqhwHZc

Sorry about that. I had to remove and readd the rules. The AI was convinced that my isp was blocking it but he was wrong wrong wrong.

Never believe the AI while troubleshooting. LOL

I6_I6 wrote: February 17th, 2026, 5:11 pm This is pretty cool!
As far as I can see, there isn't anything wrong with the simulation, in both versions. Performance is also good.

However, while I was messing around with the React version, I had this glitch that made the simulation loop. (I honestly don't know if I accidentally pressed something that made it loop as an intentional feature). I don't know how to upload videos here though.

Overall, the websites are nice and feature-rich, but here are some suggestions of what to add:

• Pattern selection: Add a selection tool that lets you select rectangular portions of the grid, which the user can then manipulate. (Rotate, flip, nudge, copy, save, etc.) (Side note: Something I've always wanted in Golly is polygonal selection, but that might be a stretch.)
• Speed control: More precise simulation speed control, since the current one is a bit hard to understand. Might be useful to add more info at the top.
• Reset: Add a 'reset' button which allows the user to return to generation 0.
• Copy+paste RLE: Allow copying, cutting and pasting of patterns. Patterns can be stored as text using Run Length Encoded (RLE) format. This is very useful, and most other platforms support it, so the user would be able to copy and paste things across different simulators.
• Import/download patterns: Import pattern files that are in RLE (.rle) (or macrocell, .mc) format and download patterns as files.
• OCA support: Support OCAs (other cellular automata) and not just Conway's Game of Life. This could be done by adding a feature where the user could input a rulestring to specify the rule.
• Help window: Add a 'help' popup that explains things about the simulator and how to use it and things like keyboard shortcuts.

Also, I'm not entirely sure why there are separate Hashlife and 'normal' algorithms when you can just use Hashlife. The patterns will still evolve the same, but Hashlife would be faster (assuming normal mode is just calculating the neighbors of live cells without hashing).

You might want to check out Golly or LifeViewer, which are the most widely use CA simulators. They might give you some ideas. (Golly is an app you can download here.)