https://github.com/xloem/log/blob/wip/multicapture.py#L14L29 # indexes a balanced tree of past indices class append_indices(list): def __init__(self, degree = 2, initial_indices = []): super().__init__(*initial_indices) self.degree = degree self.leaf_count = 0 def append(self, last_indices_id): self.leaf_count += 1 leaf_count = self.leaf_count idx = 0 for idx, (sub_leaf_count, value) in enumerate(self): if sub_leaf_count * self.degree <= leaf_count: break leaf_count -= sub_leaf_count idx += 1 # to append if the loop falls through self[idx:] = [(leaf_count, last_indices_id)] I am quite satisfied and proud of putting this together. It produces a balanced binary tree from append-only data like the dat project's protocol, but is only a handful of lines long and uses few operations. I made it to try to draft another cryptographic livestreaming system. Still haven't quite reached workability yet. It does _not_ include random writes as pursued in the other thread for a bit, which i decided i wanted to do by organizing trees to be deepest away from recent writes. The theory is quite similar, of used indices obscuring the content of deeper indices, keeping the depth of the tree bounded even when including references to deeper leaves. When I was making it, I was in one of my confusing situations where I was using an offline terminal with a working keyboard via serial cable to connect to a raspberry pi without a keyboard where i used mosh over yggdrasil to connect to a firewalled remote system that had more resources than local things. Something had started going wrong with the network or possibly remote i/o, and keystrokes were very slow. The algorithm was quite hard for me to think about, and the delay with keystrokes was making it harder. I disconnected from all the things, and tried hard to draft it locally. I had struggle-fun with it, and kept reorganising it until it got small. I worked on it inside a local tmux session, so I then opened up the serial terminal and mosh again from within the local tmux session, and used tmux's buffer support to copy the text over. The end result actually works; I blockchained some audio from an android phone, and after a lot of dev attempts downloaded the audio again off a network peer, and reconstructed it from the index trees, and played it. However, the upload process was too slow, and most of the content was lost from recording overrun; the download contained only interspersed brief clear snippets of audio pasted together. Still, so close!! and it's enough to prove something happened from your phone. It runs in tmux and uses the android audio hardware.