specs

Is there an easy way to comply with an accountable, non-oprressive-regime e.g. at least CSAM IPFS block list? "Implement Allow Lists and Block Lists" (2018) https://github.com/ipfs/notes/issues/284 "IPIP 298: (allow|deny)lists for IPFS Nodes and Gateways" (2022) https://github.com/ipfs/specs/pull/340

Hey there! I’m one of the first developers to work on IPFS, and was the maintainer of the project for around three years. I’ve since been pulled into working on Filecoin, which has definitely taken away from the time I can spend pushing IPFS forward. That said, the IPFS Project has a really solid team and OSS community still pushing the project forward, and there is an entire team working on just libp2p (the network stack used by IPFS and other projects like Livepeer, Ethereum 2.0, OpenBazaar, and more). There’s been a ton of progress made recently, and the network has grown significantly. We’ve gone from nearly 30k peers last year (this is hard to estimate accurately, but best guess) to around 400k peers on the network today — roughly 13x growth. This massive influx in usage has taken a lot of our attention up, things catching fire that

IPFS also needlessly rolled their own TLS replacement: https://github.com/ipfs/specs/issues/29 > I would add that if TLS can be used without all the X.509 nonsense, and with our own choice of pubkeys, including using different signing public keys (not the DHE keys) in the same conn, then we can consider breaking our "not TLS pls" stance. TLS fit their requirements all along, they just… decided to reinvent it instead of reading about how to use it.

> how would you implement a Hacker News style aggregator that updates every minute AIUI, that's the problem that IPNS is designed to solve (https://github.com/ipfs/specs/blob/master/naming/README.md#i...). HN controls its private key, enabling it to be the only one who can update the record at the signature of its public key, and those IPNS records have nanosecond precision expiry timestamps and TTLs, meaning they can update at the frequency of their choice I agree with the sibling comments that (at least as the IPFS is currently specified) having a user session would be problematic. It's theoretically possible that _your_ HN front page would have an IPNS record of IPFS://mdaniel.news.ycombinator.com and then we're back to the aforementioned expiry semantics. Upvotes would have to travel out of the IPFS network, but in some sense, I think

Very interesting! We've been using HAMTs in IPFS [1] to make huge directories more efficient (think NPM or Wikipedia), and the memory profile has been a pain, so this looks like a welcome improvement. [1] https://github.com/ipfs/specs/issues/32

Actually there's been some movement regarding URLs :) You can check out the reasoning and plan here: [1] IPFS still has the long-term goal of path addressing (NURI), we just hadn't yet completely figured out what the upgrade path should look like. The discussion linked above is turning into a spec and into actions, i.e. IPFS will be trying to get as much as possible of Electron's protocol API [2] into WebExtensions, [3] and make us of that in the browser addons. [4] [1] https://github.com/ipfs/specs/pull/152#issuecomment-28462886... [2] https://electron.atom.io/docs/api/protocol/ [3] https://bugzilla.mozilla.org/show_bug.cgi?id=1271553 [4] https://github.com/ipfs/in-web-browsers

Acknowledged -- the documentation around IPFS and libp2p is not exactly delighful yet :) A new community member as written up their notes on diving into the IPFS ecosystem here: https://github.com/ipfs/specs/issues/145

We have bunch of interfaces + tests you can use and also a good place to start is over here: https://github.com/ipfs/specs/blob/master/overviews/implemen... We want to make it easier though, and haven't really got there yet. But if you have questions, #ipfs on freenode is a good place where core devs and the community hang around usually.

Hi! (Another IPFS dev here :)) IPFS supports today WebRTC, TCP, uTP and WebSockets, thanks to the multi transport approach libp2p[0] offers. In fact, that is how Orbit works, a chat app build completely in JS, using IPFS, on the browser without any plugins. Check: - http://orbit.libp2p.io/ - https://github.com/haadcode/orbit The js-ipfs DHT is underdevelopment, in fact, we have an implementation, but it is not compatible with go-ipfs so we are not rolling it out, yet. To check the latest updates on the project and learn whats next, check our log https://github.com/ipfs/js-ipfs/issues/30#issuecomment-22604... [0] - libp2p is the network stack of IPFS, also a standalone project https://github.com/ipfs/specs/tree/master/libp2p

Thanks for the interest everyone! We think libp2p is one of the most exciting and useful parts of the IPFS project. We've refactored it out of IPFS for the benefit of the general p2p / networking community. We're working on cleaning up interfaces, getting to a good level of completeness and interop between go and js, and then messaging/explanations. Stay tuned for proper a launch later on. But note both go-libp2p and js-libp2p are usable and in use now. :) - Go: https://github.com/ipfs/go-libp2p - js: https://github.com/diasdavid/js-libp2p - specs: https://github.com/ipfs/specs/tree/master/libp2p brb, 8hr flight.

I'd love to see that. I think versioning is possible in IPFS via merkle tree, but I haven't taken the time to understand how it would be implemented. https://github.com/ipfs/specs/tree/master/merkledag

One of the things I am most looking forward to is the abstraction into libp2p[1]. I am wanting to try out my own ideas but I don't want to hassle w/ building my own Kademlia DHT or NAT traversal. 1 - https://github.com/ipfs/specs/tree/master/libp2p

Thanks very much to Christian and John for writing a much needed detailed article :) Some more links for people to check out: ## (upcoming) IPLD "merkleized JSON" format: - improves upon our basic format to make it much more pleasant to build things on top of ipfs. - JSON meets CBOR meets Merkle-linking - mini-spec: https://github.com/ipfs/specs/blob/master/merkledag/ipld.md ## answers to some common questions i've read on this page: - content model / replication: https://github.com/ipfs/faq/issues/47 - how resolution works: https://github.com/ipfs/faq/issues/48#issuecomment-152917088 - how IPNS / mutable linking works: https://github.com/ipfs/faq/issues/16 - this is a very poor answer, sorry, i'll write up a post or paper on it. - for now if interested, see the QConf slides below, specifically slides ~110 to ~130 -- the DNS, IPRS, SFS/Ma

Hi Alexander, this is really great! I've started `registry-mirror` to demonstrate how a Content-Addressed file structure and P2P discovery, can bring a lot of speed improvements, specially when the bottleneck is low bandwidth/latency to the backbone, by connecting to more local peers that have the content that we are looking for. Right now, the goal with `registry-mirror` is to have a very large IPFS node in the network with the entire npm and that keeps replicating it, while end user machines only download the modules they need (and if they agree, provide them to the network as well). Each end user will be able to get the latest state of the registry, through a IPNS hash, a mutable pointer, that changes each time the mirror is updated. The nix package manager model layers perfectly on top of IPFS' MerkleDAG (https://github.com/ipfs/specs

(IPFS author here) You're hitting on some really hard questions :) the gist is that you use a "record system" that has some transport guarantees, for example relying on a dht has certain kind of properties, as opposed to relying on pub/sub over trusted nodes. IPFS has this part as pluggable, though we're focusing on a large public DHT first. DHTs are pretty robust today, though yes have weaknesses we're working on. now, the key is that, on top of that, you build assurances around cryptographic freshness (i.e. "trust this record for a certain amount of time"). of course, "certain amount of time" varies with your notion of time (e.g. NTP, vs blockchain times, etc), so the user gets to set that. if you're interested in how the "record system" works and will evolve, take a look at https://github.com/ipfs/specs/tree/master/records -- though ad