Fast way to create an animation from binary data

I have a C++ program which writes pixel data for a 2D grid to a binary file. Each binary file may have numerous grid states back-to-back, and there may be multiple of these binary files.

e.g. I could have 10 binary files bin0, bin1, bin2... bin9 each holding data for 10 grid states for a total of 100 grid states to animate.

I'm looking for a fast way to create an animation from the grid states in these binary files.

My best attempt used python and PIL.Image to create a gif:

import glob
import numpy as np
from PIL import Image
from functools import partial

def create_images():
    paths = glob.glob('./outfiles/dump*')
    imgs = []
    for path in sorted(paths, key=lambda x: int(x.split("p")[1])):
        with open(path, 'rb') as ifile:
            for dat in iter(partial(ifile.read, rows*cols), b''):
                mem = memoryview(dat).cast('B', shape=[rows,cols])
                arr = np.asarray(mem)
                img = Image.fromarray(arr*255)
                imgs.append(img)
    return imgs

rows = 128
cols = 128
imgs = create_images()
imgs[0].save('./animation.gif', save_all=True, append_images=imgs[1:], loop=0)

but the final line where I actually write the gif can take a long time if I have potentially thousands of images, each with thousands of pixels. The rendering of the gif is also poor quality when the images are large.

Looking forward to suggestions for how to make this run fast using a different library from Pillow. Not bothered about sticking to Python if there is a better alternative using C/C++ (or other languages, but Python or C/C++ preferred), nor does the animation have to be a gif.

In my case I'm working with grid data which is either 0 or 1 (the context is Conway's Game of Life), so optimizations which take advantage of this would be welcome. Note, however, that currently each 1 or 0 occupies a whole byte in the binary file, therefore are not packed into bits.

EDIT

Just adding a helper python script to generate binary files as I described above for anyone who gives it a go.

import numpy as np

rows = 128
cols = 128

img_per_file = 10
num_files = 3

filesize = rows*cols*img_per_file

for i in range(num_files):
    filename = 'bin'+str(i)
    data = np.random.randint(2, size=filesize, dtype=np.uint8).tobytes()
    f = open(filename, 'wb')
    f.write(data)
    f.close()