You can work on shared files instantly without uploading or downloading them.

1 minute video: https://www.youtube.com/watch?v=9Wt0NMx2_I8 Github repo: https://github.com/KeibiSoft/KeibiDrop

Since last month hardened bidirectional edits such that people can work on video assets with Premier Pro, DaVinci, and such.

Got a pre-alpha release, where we managed to split congestion control over QUIC and bulk data transfers over TCP, and the lockless conflict resolution :D

Level 1: A basic generator does the same stuff: Raw Structs to SoA + Wire Codecs + Bitfields to not waste space.

Level 2: Then on top of this one, I got a generator for relation between entities.

Level 3: And on top of this one one for "game" design and schema behavior.

And then all this runs on the simluator engine that handles Collision, Flow Fields, Events, Genetic Algorithms, Networking, etc.

The flow is something like this:

You ask claude to read a story, novel, w/e and extract relations, entities, etc.

Then it edits a Schema.go with the High Level DSL adnotations, like 10 lines per entity.

Then I run the Level 2 Generator: That creates the primitives and a high level API.

Then it combines the high level API rules in main.go and just compiles it to the final gamestate.

And runs benchmarks to see how many allocs/ops per entity are.

And one more fun thing, it encodes the gamestate on 1400 bytes, in order to fit on a UDP datagram such that it can support networking, quite fun. Once you get the primitives correct.

For all this + networking + disk i/o; works on 4 cores (threds) only. But the simulation in itself is on 1 core 1 thread. The networking offloaded to 1 core (1 thread), and disk i/o to a different core (thread), and the painting on screen (to a different core (thread))

Why did your group use the AI, how would you answer the Conclusion questions?

As an anectdote: I like low-fi punk music because of the energy, and low skill for entry level. So when I started playing music, I went for this genre. I used it as a hobby over 10 years as it brought me joy, and enjoyed the process, without the grind for leveling up the skill.

It's also fun to do low effort things that are good enough. Much more fun than being l33t.

My goal for this experiment was to encode the optimal cache data structures into meta programming generators such that claude can write high level DSL and generate down to this level of simulations. I am curious if you had such an approach also.

KEIBIDROP: Makes remote files appear as local (it hides the network latency in order to let you open and edit a peers file without downloading it upfront or re-uploading it fully back).

For version 0.4.0 I am planning multi-user support, using UDP (QUIC) instead of TCP as the networking layer, optimization of live-edit regions of files, and to test it even more for data heavy workflows.

Here is the website: https://keibidrop.com/

And here is the github: https://github.com/KeibiSoft/KeibiDrop/

Job stuff not much related with stuff learned in school, sometimes related to some degree.

Skill stuff very closely tied to constantly applying stuff learned in school, but mostly on how to attack problems.

Me learn stuff because me like know stuff and level up. (edit: do not get me wrong, learning is still painful, and thinking even more painful)

Me job stuff because me like food and amneties, until the learn stuff transfers into sustainable food and amneties.

Assume you have a 10 GB blu ray movie that you want to watch without waiting for upload/ donwload time.

Maybe you host it on a server on another continent, where you got a 200ms RTT.

And your wire at home supports around 500Mbps - approx 62 MB/s.

Thus to Download it fully, would take around: 161 seconds if you use the full wire and on the happy case.

But to actually watch it and skim through it, you do not need to use the full wire, but around ~11 Mbps for a 2-hour 10 GB film, which is like 2% of the wire. The only hard part is random jumps, as each seek is a full RTT.

If you prefetch too aggresivelly you hide this RTT, but if the wire is saturated, and if you have a cache miss, then you will hang and wait until the request goes through. Might be upt to 1-2 seconds. The whole game is to pace yourself such that you stay ahead of the consumption rate, without saturating the wire.

Basically it went the "sshfs over iroh" approach, and instead of OP's post, it has eager metadata file sharing, and on demand file access. It is still a work on progress, but you can use git juse fine over the fuse mount points without introducing a new tool (edit: but do note that I did not encounter problems with large worktrees, as I do not use them in my flow, and still has some quirks). And still have similar "cold path" access times.

I touch on some insights of hiding the latency, the direct Alice to Bob connection, and has some recorded demos. Goes the generic approach.

You can watch it here if you are interested, but its around 25 minutes.

The first part is about the Post Quantum Crypto, and making direct IPv6 connections work.

The second part is about the filesystems in userspace that hide the latency. (The second part is around minute 12:00, and I think it is the relevant part to this discussion/ thread).

https://passthesalt.ubicast.tv/videos/2026-keibidrop-post-qu...

Setup: a Linux box on the other side of Romania (compared to where I am living) reading from a Windows box in Singapore (~200 ms RTT)

- reading 1 MiB of a 1 GB remote file pulls only 16 MiB (~98% avoided) - this is because of my fine tuning optimization choice - first byte approx: 2.3s - git-LFS repos also clone cold over the mount byte-perfect (separate Mac - Linux run on a ~20 ms RTT)

The thing that I do differently is that my metadata is eagerly pushed, as I optimized for content streaming.

And 100k-file tree mounts I did not test yet.

But my goal was to have instant file access for generic files between apps, and peer to peer, supports also Windows :D

here is the tool: https://github.com/KeibiSoft/KeibiDrop

But my TP-Link router blocks by default inbound IPv6 connections, without any option to configure it, still bad for pure IPv6 bidirectional streaming, gaming or services on home networks.

https://keibidrop.com

https://github.com/KeibiSoft/KeibiDrop/

It leverages virtual mount points to make file metadata available between Alice and Bob, and make the files appear as if locally.

So for example instead of waiting to upload then download a Blu Ray movie, or a large game, you can just add it into the virtual mountpoint and your recipient can instantly play it, or install it, and the download happens in the background with random offset jumps, and caches it locally.

My favorite part of it is Chapter 2 the bit manipulation tricks.

I managed to get around 8192 using Serge Skoredin's approach from the blog post last year: https://skoredin.pro/blog/golang/cpu-cache-friendly-go

Also tried some of the techniques in this blog post, and managed to squeeze a bit more with the insights from your post.

As soon as I merge this one, will create another release that fixes the fallback; and hopefully also get the apps in ios and gplay stores. https://github.com/KeibiSoft/KeibiDrop/pull/143

https://keibidrop.com/ repo: https://github.com/KeibiSoft/KeibiDrop

Might tend to deviate and waste time, needs guiding once in a while, and to check what is it spewing out, point it in the correct direction.