A wooden frame with 64 green LEDs running a Game of Life simulation

Wooden CNC Sculpture Displays Conway’s Game Of Life

August 24, 2023 by Robin Kearey 1 Comment

Conway’s Game of Life has been the object of fascination for computer hobbyists for decades. Watching the generations tick by is mesmerizing to watch, but programming the data structure and implementing the rules is also a rewarding experience, especially if you’re just getting acquainted with a new computing platform. Just as rewarding can be creating a nice piece of hardware to run the game on, as [SandwichRising] has just done: check out his beautiful wooden Game of Life implementation.

The main part of his Game is a piece of poplar wood that was CNC routed to produce an 8×8 display adorned with neat chain-like shapes. The display consists of standard 5 mm green LEDs, but they’re not the things you see poking out the front of the wooden frame. Instead, what you’re seeing are 64 lenses made out of epoxy. [SandwichRising] first covered the holes with tape, then poured green epoxy into each one and waited for it to harden. He then took off the tape and applied a drop of UV-cured epoxy on top to create a lens.

All the LEDs are mounted on PCB strips that are hooked up to a central bus going to the main ATmega328P microcontroller sitting on a separate piece of PCB. Whenever the system is powered on, the game is set to a random state determined by noise, after which the simulation begins. On such a small field it’s pretty common for the game to end up in a stable state or a regular oscillation, which is why the ATmega keeps track of the last few dozen states to determine if this has happened, and if so, reset the game to a random state again.

The source code, as well as .STL files for the PCBs and the frame, are available in the project’s GitHub repository. If woodworking isn’t your thing, there’s plenty of other ways to make neat Game of Life displays, such as inside an alarm clock, with lots of LEDS under a coffee table, or even with a giant flip-dot display.

An E-ink display showing Conway's Game of Life, with a solar cell beneath it

Solar Powered Game Of Life Follows The Sun’s Rhythm

July 28, 2023 by Robin Kearey 5 Comments

Conway’s Game of Life is a beautiful example of how complex behavior can emerge from a few very simple rules. But while it uses biological terminology such as “cells”, “alive” and “generation”, the basic game is too simplistic to be a model for any real-world biological process. It’s easy to add features to make it a bit more life-like, however, as [David Hamp-Gonsalves] has done by giving the Conway’s creation something of a circadian rhythm.

The basic idea is that the speed at which [David]’s Game of Life evolves is governed by the amount of ambient light. The game runs off a solar cell that charges a battery, with the battery’s voltage determining how long it takes to advance the game by one generation. The system is therefore highly active in full sunlight, and grinds almost to a complete halt at night.

An ESP32 runs the simulation and outputs the result to a 400 x 300 pixel e-ink display. The display is extremely power-efficient by its very nature; the ESP’s main processor core, on the other hand, is deliberately placed into deep sleep mode most of the time to save as much power as possible. The Ultra Low Power (ULP) co-processor, meanwhile, keeps an eye on the lithium battery’s voltage as it’s slowly being charged by the solar cell. When the voltage reaches 3.3 V, the main CPU wakes up and computes the Game’s new state. In bright sunlight this happens every few seconds, while on an overcast day it could take minutes or even hours.

[David]’s interesting idea of changing Life‘s activity based on the amount of energy available turns the Game into something resembling a cold-blooded animal. We’ve seen a similar approach in a “solar creature” that runs a Life-life simulation on a seven-segment LCD. If it’s speed you care about however, you’re better off implementing Life in an FPGA.

This Retro Game Console Puts Vacuum Fluorescent Display To Good Use

March 7, 2023 by Dan Maloney 4 Comments

Small in size, low-resolution, blocky segments, and a limited color palette — all characteristics of the typical vacuum fluorescent display, any of which would seem to disqualify them as the display of choice for a lot of applications. But this is Hackaday, and we don’t really pay much attention to what we’re supposed to do, but rather to what’s fun and cool to do. So when we see something like a VFD game console, we just have to sit up and take notice.

In a lot of ways, the design of [Simon Boak]’s Arduino-based VFD console is driven by his choice of display. The Noritake Itron GU20X8-301 VFD is a “tricolor” display with eight rows of 20 rectangular pixels. Each pixel is composed of six short linear segments, with alternating red and blue colors. Turning on either set of segments yields one of the two base colors, while turning on both yields a sorta-kinda whitish color, if you squint a bit.

[Simon] chose a two-piece design for his console, with a separate controller and display. The controller holds the Arduino Nano and all the controls, plus a piezo buzzer for fun. The display case connects to the controller with a ribbon cable and holds the VFD power supply and driver. To celebrate the retro look of the VFD, both cases are decked out with woodgrain side panels. [Simon] chose appropriately blocky games for the console, like Snake, Conway’s Game of Life, and the venerable snow demo. We’d imagine Pong would be a good choice too, as well as perhaps Tetris if the display were flipped on its side.

We really like the look of this console, and we appreciate putting an otherwise obsolete display to use in a creative way. If you want to learn a little more about these displays, check out this love letter to the VFD.

Continue reading “This Retro Game Console Puts Vacuum Fluorescent Display To Good Use” →

Old Casio Calculator Learns New Tricks

April 6, 2022 by Chris Wilkinson 12 Comments

[George Stagg] recently found himself stung by the burden of free time while in lockdown. Needing a project to keep him occupied, he decided to upgrade his 90s Casio CFX-9850G calculator to run custom machine code.

All [George] really wanted was for his vintage calculator to understand Reverse Polish Notation (RPN). The calculator in question can already run its own version of BASIC, however the bespoke Hitachi CPU struggles performance-wise with complex programs, and wouldn’t be a realistic way of using RPN on the calculator. An RPN interpreter written in assembly language would be much faster.

The first step in cracking this calculator wide open was a ROM dump, followed by writing a disassembler. Incredibly, the MAME framework already featured a ‘partial implementation’ of the calculator’s CPU, which was a much needed shot in the arm when it came time to write a full-featured emulator.

With the entire calculator emulated in software, the plan from here involved replacing one of the BASIC commands in ROM with new code that would jump to an address in RAM. With 32KB of RAM there ended up being plenty of room for experimentation, and uploading a program into RAM was simplified by using Casio’s original backup software to dump the RAM onto a PC. Here, the contents of RAM could be easily modified with custom code, then uploaded back into the calculator.

With RAM to burn, new routines were created to write custom characters to the screen, and a new font was created to squeeze more characters onto the display than normal. [George] ended up porting a Forth interpreter, which defaults to RPN style, to finally achieve his humble objective. He also managed to get a version of Conway’s Game Of Life running, check out the video after the break.

We can’t get enough of our calculator hacks here, so make sure to check out the CPU transplant on this vintage Soviet calculator.

Continue reading “Old Casio Calculator Learns New Tricks” →

The Game Of Life Moves Pretty Fast, If You Don’t Use Stop Motion You Might Miss It

November 11, 2021 by Matthew Carlson 12 Comments

Munged Ferris Bueller quotes aside, Conway’s Game of Life is the classic cellular automata that we all reach for. The usual approach is to just iterate over every cell in the grid, computing the next state into a new grid buffer. [K155LA3] set out to turn that on its head by implementing Game Of Life in the hardware of an FPGA.

[K155LA3]’s version uses Chisel, a new HDL from the Berkley and RISCV communities. Under the hood, Chisel is Scala with some custom libraries that know how to map Scala concepts onto hardware. In broad strokes, Verilog and VHDL are focused on expressing hardware and then added abstraction on top of that over the year. Chisel and other newer HDL languages focus on expressing high-level general-purpose elements that get mapped onto hardware. FPGAs already map complex circuits and hardware onto LUTs and other slices, so what’s another layer of abstraction?

The FPGA chosen for this project is a Digilent Arty A7 with a VGA Pmod to turn the RGB444 into analog signals to actually display. What’s impressive about [K155LA3]’s implementation is just how fast it is. Even running at 60 frames per second it’s almost as fast as the monitor can handle. Of course, most computers lying around you could simulate a 60 x4 8 grid at 60 fps. Next, instead of connecting the grid logic to the 60 Hz VGA clock, he connects it to the 100 MHz board external oscillator. Now each pixel in each frame displayed contains over a million generations.

Unfortunately, even this small grid of 60×48 takes up 90% of the LUTs on the Artix-7. In the future, we’d love to see an even larger FPGA hardware implementation capable of handling grids that could hold whole computers in them. And naturally, this isn’t the first FPGA version of the Game Of Life here at Hackaday.

A Computer In The Game Of Life

November 21, 2020 by Matthew Carlson 20 Comments

We often hear the term “Turing-complete” without giving much thought as to what the implications might be. Technically Microsoft PowerPoint, Portal 2, and Magic: the Gathering all are Turing-complete, what of it? Yet, each time someone embarks on an incredible quest of perseverance and creates a computer in one of these mediums, we stand back in awe.

[Nicolas Loizeau] is one such individual who has created a computer in Conway’s Game of Life. Unlike electricity, the Game of Life uses gliders as signals. Because two orthogonal gliders can cancel each other out or form a glider eater if they intersect with a good phase shift, the basic logic gates can be formed from these interactions. This means the space between gates is crucial as signals need to be in phase alignment. The basic building blocks are a period-60 gun, a 90-degree glider reflector, a glider duplicator, and a glider eater.

All the Python code that generates these structures is on GitHub as the sheer size of the machine couldn’t possibly be placed by hand. The Python includes scripts to assemble the basic programs as a bank of selectable glider generators. It’s all based on Golly, which is an excellent program for simulating Conway’s Game of Life, among other things. While this isn’t the first computer in the Game of Life as [Paul Rendell] published a design in 2000 and [Adam Goucher] published a Spartan universal computer constructor in 2009, we think this is a particularly beautiful one.

The actual architecture has an 8-bit data bus, a 64-byte memory with two read ports, a ROM with 21 bits per line, and a one-hot encoded ALU supporting 8 different operations. Instructions have a 4-bit opcode which is decoding in a few different instructions. The clock is four loops, formed by the glider reflectors as the glider beams rotate. This gives the computer four stages: execution, writing, increment PC, and write PC to memory.

The Game of Life is an excellent example of Cellular Automaton (CA). There are several other types of CA’s and the history behind them is fascinating. We’ve covered this field before and delved into this beautiful fringe of computer science. Check out the video below to truly get a sense of the scale of the machine that [Nicolas] has devised.

Continue reading “A Computer In The Game Of Life” →

The Game That Launched 1,000 Hackers

April 18, 2020 by Elliot Williams 6 Comments

John Conway passed away this week. Even if you don’t know much about mathematics, you will probably know nearly everyone’s favorite cellular automata ruleset: Conway’s “Game of Life”. It’s so much a part of our cultural history, that proto-hacker Eric Scott Raymond suggested using the glider as the hacker emblem.

The idea that a very simple set of rules, applied equally and everywhere, could result in “life” was influential in my growth as a young hacker, and judging from the comments on our article about Conway, I’m not alone. But I won’t lie: I was a kid and thought that it could do much more than make pretty patterns on the screen. I was both right and wrong.

Although amazingly complex machines can be built in Conway’s Life, just check out this video for proof, in the end no grand unifying theory of cellular automata has emerged. As a research topic Conway’s chosen field of mathematics, cellular automata is a backwater. It didn’t really go anywhere. Or did it?

Implementing Conway’s Life in BASIC on a Tandy Color Computer was one of the first things that launched me on my geeky path. It ranks with MENACE: the matchbox-based machine learning algorithm from the 1960’s and an introduction to Markov Chains in the form of a random text generator in my young algorithmic life, all of which I incidentally read about in Martin Gardner’s column in “Scientific American”. Conway’s Life, along with some dumb horse-race game, also taught me about bad random-number generators: the screen would populate the same “randomly” every time on the old CoCo.

So maybe Conway didn’t want to be remembered just for his “Life” because it was a bit of a mathematical dead-end. But in terms of its impact on the world, an entire generation of hackers, and my own personal life, it was able to fill up significantly more than a screen full of pixels. Here’s to Conway, his “Life”, and everyone else who is inspiring the next. You’re not just gliders, you’re glider guns!

[Game of Life example shown in this article is John Conway’s Game of Life – 1.0 written in Python by Nick Jarvis and Nick Wayne]