Nebulus: An IPFS-Less IPFS
nebulus.dev
Nebulus: An IPFS-Less IPFS
1–10 of 42 posts
Re: Nebulus: An IPFS-Less IPFS
#2This looks cool! I'm writing an immutable data store, with my own hashes as IDs; I wonder how viable it would be to use IPFS CID's as my IDs?
I expect the trouble there would be how the data is chunked. If IPFS disagrees about the chunking we would have different CIDs.
.. also i'd need to implement all of this myself to get it in Rust. Hmm.
Re: Nebulus: An IPFS-Less IPFS
#3This looks cool! I'm writing an immutable data store, with my own hashes as IDs; I wonder how viable it would be to use IPFS CID's as my IDs? I expect the trouble there would be how the data is chunked. If IPFS disagrees about the chunking we would have different CIDs. .. also i'd need to implement all of this myself to get it in Rust. Hmm.
https://github.com/ipfs-rust
Maybe some of the building blocks you need can be found in there somewhere.
Re: Nebulus: An IPFS-Less IPFS
#4Two things:
1) I wonder why this wasn't written in a language that can compile to wasm, so it could be used on both native and js without reimplementing.
2) Can someone contrast hypercore and IPFS?
Re: Nebulus: An IPFS-Less IPFS
#5This looks cool! I'm writing an immutable data store, with my own hashes as IDs; I wonder how viable it would be to use IPFS CID's as my IDs? I expect the trouble there would be how the data is chunked. If IPFS disagrees about the chunking we would have different CIDs. .. also i'd need to implement all of this myself to get it in Rust. Hmm.
https://github.com/ipfs-rust Maybe some of the building blocks you need can be found in there somewhere.
Not implementing the core of the protocol in something portable-library-friendly has been a real drag on IPFS. It's made it, in practice, more of a program than a protocol.
The counter-argument is that they'd not have made so much progress in the first place, in the short list of languages that qualify as portable-library-friendly.
Re: Nebulus: An IPFS-Less IPFS
#6Two things: 1) I wonder why this wasn't written in a language that can compile to wasm, so it could be used on both native and js without reimplementing. 2) Can someone contrast hypercore and IPFS?
Hypercore distributes signed log-based structures addressed by pubkey. It embeds indexes in each log entry to make this perform well; for instance Hyperbee is a b-tree over a log. (See https://github.com/hypercore-protocol/p2p-indexing-and-searc... for how that works.)
IPFS distributes content-addressed blobs which interlink to form DAGs. Mutability is supported by pubkey (or similar) pointers to recent hashes.
I work with Hypercore. It’s often a matter of preference between them.
Re: Nebulus: An IPFS-Less IPFS
#7This entire project can be replaced in two different ways with just IPFS. You don't have to run IPFS to be able to add files or retrieve them (if you've added them on the same computer), so simply add the files without running the daemon and you're already "Offline and Private" and "IPFS without the Network".
If that's not enough, you can also run your IPFS daemon with `--offline` and it won't connect to any network, giving you another way of using IPFS offline and privately.
If you want to go one step further, when adding files with the IPFS CLI, you can add the flag `--only-hash` and IPFS will only hash the content without actually writing anything to disk, making it even more "offline" and "private".
All in all, this seems to be a project whose author missed to read the documentation for IPFS as everything mentioned is already supported in go-ipfs, the main IPFS implementation.
Edit: the title "IPFS-less IPFS" is fun too, since nebulus seems to include ipfs-core as a dependency, not really IPFS-less then I'd say :) https://github.com/skogard/nebulus/blob/480d43dc22ccd949c6ae...
Re: Nebulus: An IPFS-Less IPFS
#8Two things: 1) I wonder why this wasn't written in a language that can compile to wasm, so it could be used on both native and js without reimplementing. 2) Can someone contrast hypercore and IPFS?
> 1) I wonder why this wasn't written in a language that can compile to wasm, so it could be used on both native and js without reimplementing.
The most straightforward answer is, I extracted this out of an existing project I've been working on: https://rarepress.org/ I had to build a system that makes use of IPFS without having to publish everything to the public network, and this was where the idea came from. But the "IPFS-Less IPFS" turned out to be much more powerful idea than I originally thought, so decided to turn it into its own open source project.
That said, I think it shouldn't be difficult to implement this using Go at some point if this approach becomes popular. For now I wanted to keep the initiative minimal so I can move fast.
> 2) Can someone contrast hypercore and IPFS?
This is a great question in this context. Hypercore is more focused on the networking aspect, but IPFS is not just a networking protocol but also a way to represent files using immutable identifiers (content addressable file system). What I just did with Nebulus is unbundle the "file system" from the "network" so we can use IPFS in more flexible manner.
Speaking of Hypercore, because Nebulus unbundles the network aspect of IPFS from the content addressable file system aspect, it is possible to use ANY network transport to replicate IPFS files, which includes Hypercore.
Re: Nebulus: An IPFS-Less IPFS
#9Very confused by the name. I thought this was related to the Nebulous Labs (the startup behind the Sia storage network) and their work around IPFS: https://blog.sia.tech/skynet-summer-2021-update-86ed8db21eae
Re: Nebulus: An IPFS-Less IPFS
#10Two things: 1) I wonder why this wasn't written in a language that can compile to wasm, so it could be used on both native and js without reimplementing. 2) Can someone contrast hypercore and IPFS?
Hypercore distributes signed log-based structures addressed by pubkey. It embeds indexes in each log entry to make this perform well; for instance Hyperbee is a b-tree over a log. (See https://github.com/hypercore-protocol/p2p-indexing-and-searc... for how that works.) IPFS distributes content-addressed blobs which interlink to form DAGs. Mutability is supported by pubkey (or similar) pointers to recent hashes. I wor…
I mentioned this in above thread, but I am thinking of ways to mash up Nebulus with Hypercore (Because the content addressable aspect has been unbundled from the networking aspect of IPFS, I think there will be some interesting ways to deliver IPFS over Hypercore). Will keep the hypercore community posted when I make some progress, and thank you for all your work with Hypercore. I use Hypercore for several of my projects.