The buffer is a GRIB module that makes it easier to process data in roons.

The buffer lets you:

• Store data twice as efficiently
• Easily set up inputs to your patterns
• Visualise outputs from your patterns
• Send marbles over long distances without manual setup
• Create arbitrarily-sized memory blocks in moments

The buffer comes with a set of binary markers for labelling inputs/outputs.

Note: requires a GRIB drive to function (sold separately — open-source version also available for 3D printing)

memory

Each buffer has 64 cells, allowing it to store twice as much data as a single roons disk, while not requiring you to use up any tiles. This makes it convenient for compactly storing up to 8 bytes of data.

We can customise exactly how much of our buffer is used to store data by placing different roons at the entry/exit points. For example, we could have:

• A single 8-byte block of memory
• Two separate 4-byte blocks
• A 4-byte block, leaving the other 4 channels open for data transfer
• Four 2-byte blocks
• etc

data input

When testing a pattern, we typically want to provide a variety of inputs to check that it’s working.

A buffer makes this easy to set up. We just place the required sequence of marbles on each data channel and run the pattern — no additional work required.

output visualisation

Buffers also make it easier to read the output of a pattern. By wiring the output into a buffer’s channel, we can readily see the result of the computation. And because a buffer has twice the capacity of a regular disk, we can output a full byte of data before the marbles reach the end.

transfer

For larger patterns, it’s sometimes necessary to transport data across large distances. Instead of manually setting up paths for your data, the buffer automatically provides 8 channels — 4 going north, 4 going south — making it easy to send data across a full disk’s length.

chaining

Adjacent buffers can feed directly into each other, without any extra setup. Two buffers in sequence can hold 16 bytes; four buffers can hold 32 bytes.

We can also place buffers in parallel (though this requires roons to be placed to wire up their inputs/outputs). Combined with placing buffers in sequence, we can create an arbitrarily-sized grid of buffers to hold as much data as we want.