Just doodling, so I did not work out the period, but here's an oscillator like the above that can recirculate a glider through the sequence instead of just shuttling it back and forth.

Code: Select all

```
# [[ STEP 8 ]]
# [[ GPS 60 ]]
x = 121, y = 47, rule = critters
15$19bo10bo4bo18bo39bo9bo$18bo25bo16bo7bo6bo7bo20bo$17bo26bo16bo7bo6b
o7bo21bo$30bo4bo18bo39bo9$33bo31bo$17bo17bo70bo$18bo16bo69bo$19bo13bo
31bo38bo!
```

Also, here is a very simple stream splitter. However, I think it only works at periods that are 8 mod 12 (20, 32, 44, etc.) so it can't be cascaded.

Code: Select all

```
#C [[ RLE input o$bo$bo$o! ]]
#C [[ PASTET EVERY 32 ]]
#C [[ PASTE input 3 4 ]]
x = 34, y = 13, rule = critters
5$3bo15bo10bo$4bo15bo8bo$4bo15bo7bo$3bo15bo7bo!
```

Note that every odd power of 2 is 8 mod 12: 32, 128, 512, etc. With a little rephasing, we can get the splitter to work for 64 and then it works for 128 without any help.

Code: Select all

```
#C [[ RLE input o$bo$bo$o! ]]
#C [[ PASTET EVERY 32 ]]
#C [[ PASTE input 1 52 ]]
x = 103, y = 102, rule = critters
23$62bo25bo$60bo26bo$61bo28bo$59bo29bo7$48bo11b2o$46bo12bo2bo$46bo$48b
o$41b2o$41b2o15$bo15bo15bo15bo12bo$2bo15bo15bo15bo9bo$2bo15bo15bo15bo
10bo$bo15bo15bo15bo9bo3$59bo2bo$60b2o31$59bo2bo$60b2o!
```

This 5-cell oscillator came up in a search. It can turn a period-8n stream (such as period 32) but every other glider is staggered, making it possible to turn them using the older approach. This is a lot more compact than using a pair of glider relays to do the staggering.

Code: Select all

```
#C [[ RLE input o$bo$bo$o! ]]
#C [[ PASTET EVERY 32 ]]
#C [[ PASTE input 3 22 ]]
x = 39, y = 37, rule = critters
9$30b2o8$25b2o$25b2o5$3bo15bo$4bo15bo$4bo15bo10b2o$3bo15bo13bo$30b2o!
```

A search turned up this splitter that only works for period 64 streams.

Code: Select all

```
#C [[ RLE input o$bo$bo$o! ]]
#C [[ PASTET EVERY 64 ]]
#C [[ PASTE input 4 8 ]]
x = 84, y = 18, rule = critters
8$80bo$5bo31bo31bo6bo$6bo31bo31bo6bo$6bo31bo31bo$5bo31bo31bo5bo4bo!
```

Finally, it's a little inelegant, but the even powers of two can be made to work with the period-12 splitter using a period-64 glider shuttle. So the splitters can be cascaded indefinitely into the equivalent of a binary ripple counter.

Code: Select all

```
#C [[ RLE input o$bo$bo$o! ]]
#C [[ PASTET EVERY 32 ]]
#C [[ PASTE input 5 124 ]]
x = 124, y = 136, rule = critters
5$112bo$111bo$114bo$113bo7$108bo$99bo7bo$103bo$104bo$104bo$103bo$107b
o10bo$108bo8bo13$92bo21bo$91bo20bo$90bo22bo$89bo21bo7$86bo$77bo7bo$81b
o$82bo$82bo$81bo$85bo10bo$86bo8bo13$68bo20bo$67bo22bo$70bo20bo$69bo22b
o7$64bo$55bo7bo$59bo$60bo$60bo$59bo$63bo10bo$64bo8bo13$48bo20bo$46bo23b
o$47bo19bo$45bo22bo7$42bo$33bo7bo$37bo$38bo$38bo$37bo$41bo10bo$42bo8b
o13$5bo15bo15bo10bo$6bo15bo15bo8bo$6bo15bo15bo7bo$5bo15bo15bo7bo!
```

Here's a slightly improved splitter for even powers of two.

Code: Select all

```
#C [[ RLE input o$bo$bo$o! ]]
#C [[ PASTET EVERY 64 ]]
#C [[ PASTE input 5 24 ]]
x = 63, y = 34, rule = critters
9$52bo9$48b2o$39bo$47bo2bo3$47bo$48bo$5bo31bo20bo$6bo31bo18bo$6bo31bo
17bo$5bo31bo17bo!
```

Here it is cascaded.

Code: Select all

```
#C [[ RLE input o$bo$bo$o! ]]
#C [[ PASTET EVERY 32 ]]
#C [[ PASTE input 7 207 ]]
x = 189, y = 221, rule = critters
9$178bo$177bo$176bo$175bo3$159bo2$166bo$165bo$165bo8bo$166bo6bo8$169b
o3$164bo13bo$163bo13bo$162bo13bo$161bo13bo3$145bo2$158bo$157bo3$157bo
2bo$158b2o6$155bo3$150bo13bo$149bo13bo$148bo13bo$147bo13bo3$131bo2$138b
o$137bo$137bo8bo$138bo6bo8$141bo3$136bo13bo$135bo13bo$134bo13bo$133bo
13bo3$117bo2$130bo$129bo3$129bo2bo$130b2o6$127bo3$122bo13bo$121bo13bo
$120bo13bo$119bo13bo3$103bo2$110bo$109bo$109bo8bo$110bo6bo8$113bo3$108b
o13bo$107bo13bo$106bo13bo$105bo13bo3$89bo2$102bo$101bo3$101bo2bo$102b
2o6$99bo3$94bo13bo$93bo13bo$92bo13bo$91bo13bo3$75bo2$82bo$81bo$81bo8b
o$82bo6bo8$85bo3$80bo13bo$79bo13bo$78bo13bo$77bo13bo3$61bo2$74bo$73bo
3$73bo2bo$74b2o6$71bo3$66bo13bo$65bo13bo$64bo13bo$63bo13bo3$47bo2$54b
o$53bo$53bo8bo$54bo6bo8$57bo3$7bo15bo15bo15bo10bo$8bo15bo15bo15bo8bo$
8bo15bo15bo15bo7bo$7bo15bo15bo15bo7bo!
```

Here's a signal splitter that gets dragged in by the stream.

Code: Select all

```
#C [[ RLE input o$bo$bo$o! ]]
#C [[ PASTET EVERY 64 ]]
#C [[ PASTE input 3 4 ]]
x = 85, y = 15, rule = critters
5$3bo31bo31bo7bo$4bo31bo31bo$4bo31bo31bo8b2o$3bo31bo31bo9bo!
```

Here's a 90° turn that works for any period 8n+4 (I have 8n, 8n+2, 8n+6 already). It will also work for staggered output from a period 8n stream.

Code: Select all

```
#C [[ RLE input o$bo$bo$o! ]]
#C [[ PASTET EVERY 44 ]]
#C [[ PASTE input 0 0 ]]
x = 33, y = 5, rule = critters
$bo21bo3bo2bobo$2bo21bo$2bo21bo4bo$bo21bo8bo!
```

Even better, here's a 90° turn that works for any period 4n, provided there is enough spacing. The gliders can be spaced irregularly as long as they are 4n apart.

Code: Select all

```
# [[ STEP 4 ]]
# [[ GPS 10 ]]
#C [[ RLE input o$bo$bo$o! ]]
#C [[ PASTET EVERY 256 ]]
#C [[ PASTE input 5 7 ]]
#C [[ PASTE input 31 7 ]]
#C [[ PASTE input -27 7 ]]
x = 76, y = 17, rule = critters
6$66bo$5bo62bobo$6bo60b2o$6bo$5bo61bo2bo!
```

A cascaded signal splitter (or binary ripple counter) using only period-8 logic. This one uses a pair of gliders as the signal, which has the advantage that there are many ways to turn it 90° using a 180°reflector (of which there are many!). It does not require a constant input stream and can be used as a bit counter.

Code: Select all

```
#C [[ RLE input o$bo$bo$o! ]]
#C [[ PASTET EVERY 32 ]]
#C [[ PASTE input 5 28 ]]
x = 225, y = 47, rule = critters
13$30b2o22bo19bo19bo19bo19bo19bo19bo19bo19bo2$62bo39bo39bo39bo$61bo39b
o39bo39bo5$21bo31bo39bo39bo39bo39bo$22bo2$43bo9bo29bo9bo29bo9bo29bo9b
o29bo9bo$76bo39bo39bo39bo3$76bo39bo39bo39bo$5bo15bo$6bo15bo$6bo15bo8b
2o$5bo15bo8b2obo$41bo39bo39bo39bo39bo$42bo39bo39bo39bo39bo2$47bo15bo10b
o12bo15bo10bo12bo15bo10bo12bo15bo10bo12bo!
```

Another period 8n 90° turn. This one does not change the glider phase.

Code: Select all

```
x = 32, y = 32, rule = critters
$25bo$4b2o$3bobo21b2o$3b2o20bobobo$28b2o$bo2bo3$3bo2bo2$4b2o6$3bo2bo2$
4b2o6$27bo2bo$2b2o$2bobobo20b2o$3b2o21bobo$26b2o$6bo!
```

The output of the bit loop copier can be input into the binary ripple counter to count the number of bits as they are streamed.

Code: Select all

```
#C [[ RLE input o$bo$bo$o! ]]
#C [[ PASTET EVERY 32 ]]
#C [[ PASTE input 4 58 ]]
x = 193, y = 284, rule = critters
11$89bo43bo8bo13bo$92bo42bo5bo11bo$135bo5bo$90bo42bo8bo12bo7$153bo2bo
2$152bob2obo$151bo6bo7$154b2o$153bo2bo25$78bo$77bo$5bo15bo15bo8b2obo$
6bo15bo15bo8b2o$6bo15bo15bo48bo6bo$5bo15bo15bo50bo4bo3$42bo8bo20bo10b
o52bo10bo20bo10bo$41bo10bo17bo13bo49bo13bo17bo13bo$39bo12bo17bo13bo49b
o13bo17bo13bo$41bo9bo20bo10bo52bo10bo20bo10bo$40bo$42bo3$46b2o42bo12b
o8bo42bo$80b2o22bo5bo$92bo11bo5bo42bo$79bo2bo6bo13bo8bo43bo13$66bo$65b
o$75bo3bo2bo$80b2o3$63bo7$86bo2$75bo2bo5$83bo$84bo$63bo10$71bo2bo$63b
o22bo7$66bo$65bo$75bo4$63bo7$86bo2$75bo2bo5$83bo$84bo$63bo10$71bo2bo$
63bo22bo7$66bo$65bo$75bo4$63bo7$86bo2$75bo2bo5$83bo$84bo$63bo10$71bo2b
o$63bo22bo7$66bo$65bo$75bo4$63bo7$86bo2$75bo2bo5$83bo$84bo$63bo10$71b
o2bo$63bo22bo7$66bo$65bo$75bo4$63bo7$86bo2$75bo2bo!
```

All the 90° turns.

Code: Select all

```
# [[ GPS 20 ]]
x = 142, y = 91, rule = critters
5$7bo28bo$6bo30bo$5bo32bo3$76b2o$55bobo2bo17bo14bo2bo29bo$57b2o17bo47b
o7b2o$58b2o16bo18b2o27bo6b3o$57bo2bo32bobo30bo5bo$97bo$129bo$131bo2bo
$132b2o5$58b2o$57bo2bo3$98bo$130bo$75bo2bobo14bo36bobo$58bo35b3o34b2o
$58bo18bo16b2o$57b3o20bo50bo2bo$5bo2bo2$7bo9bo$19bo18bo$6b3o10bo17bo$
8bo8bo18bo15$53bo30bo$32b2o77bo$31bobo12bo6bob2o22bo30bo$31b2o11bo7bo
b2obo23bo30bo$44bo7bo3b2o55bo$29bo2bo13bo7bo27bo15$81bo2bo2$82b2o2$55b
o2bo29bo22bo$30b2o48bo6bo$30bobobo20b2o24bo5bo24bo$31b2o21bobo26bo4bo
25bo$54b2o26bo$34bo74bo!
```