Merge branch 'main' into main

package-lock.json

@@ -6364,9 +6364,9 @@
       }
     },
     "node_modules/caniuse-lite": {
-      "version": "1.0.30001470",
-      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001470.tgz",
-      "integrity": "sha512-065uNwY6QtHCBOExzbV6m236DDhYCCtPmQUCoQtwkVqzud8v5QPidoMr6CoMkC2nfp6nksjttqWQRRh75LqUmA==",
+      "version": "1.0.30001549",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001549.tgz",
+      "integrity": "sha512-qRp48dPYSCYaP+KurZLhDYdVE+yEyht/3NlmcJgVQ2VMGt6JL36ndQ/7rgspdZsJuxDPFIo/OzBT2+GmIJ53BA==",
       "dev": true,
       "funding": [
         {
@@ -6376,6 +6376,10 @@
         {
           "type": "tidelift",
           "url": "https://tidelift.com/funding/github/npm/caniuse-lite"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
         }
       ]
     },
@@ -30067,9 +30071,9 @@
       }
     },
     "caniuse-lite": {
-      "version": "1.0.30001470",
-      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001470.tgz",
-      "integrity": "sha512-065uNwY6QtHCBOExzbV6m236DDhYCCtPmQUCoQtwkVqzud8v5QPidoMr6CoMkC2nfp6nksjttqWQRRh75LqUmA==",
+      "version": "1.0.30001549",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001549.tgz",
+      "integrity": "sha512-qRp48dPYSCYaP+KurZLhDYdVE+yEyht/3NlmcJgVQ2VMGt6JL36ndQ/7rgspdZsJuxDPFIo/OzBT2+GmIJ53BA==",
       "dev": true
     },
     "caseless": {

src/.vuepress/config.js

@@ -42,20 +42,18 @@ const themeConfigDefaults = {
   ],
   footerLegal: '',
   headerLinks: [
-    { text: 'About', link: 'https://ipfs.tech/#why' },
-    { text: 'Install', link: 'https://ipfs.tech/#install' },
+    { text: 'About', link: 'https://ipfs.tech/' },
+    { text: 'Community', link: 'https://ipfs.tech/community/' },
+    { text: 'Developers', link: 'https://ipfs.tech/developers/' },
     { text: 'Docs', link: 'https://docs.ipfs.tech/' },
-    { text: 'Team', link: 'https://ipfs.tech/team' },
     { text: 'Blog', link: '/' },
-    { text: 'Help', link: 'https://ipfs.tech/help' },
   ],
   mobileNavLinks: [
-    { text: 'About', link: 'https://ipfs.tech/#why' },
-    { text: 'Install', link: 'https://ipfs.tech/#install' },
+    { text: 'About', link: 'https://ipfs.tech/' },
+    { text: 'Community', link: 'https://ipfs.tech/community/' },
+    { text: 'Developers', link: 'https://ipfs.tech/developers/' },
     { text: 'Docs', link: 'https://docs.ipfs.tech/' },
-    { text: 'Team', link: 'https://ipfs.tech/team' },
     { text: 'Blog', link: '/' },
-    { text: 'Help', link: 'https://ipfs.tech/help' },
   ],
 }
 
@@ -112,20 +110,18 @@ module.exports = {
           },
         ],
         headerLinks: [
-          { text: 'About', link: 'https://ipfs.tech/#why' },
-          { text: 'Install', link: 'https://ipfs.tech/#install' },
+          { text: 'About', link: 'https://ipfs.tech/' },
+          { text: 'Community', link: 'https://ipfs.tech/community/' },
+          { text: 'Developers', link: 'https://ipfs.tech/developers/' },
           { text: 'Docs', link: 'https://docs.ipfs.tech/' },
-          { text: 'Team', link: 'https://ipfs.tech/team' },
           { text: 'Blog', link: '/zh-cn' },
-          { text: 'Help', link: 'https://ipfs.tech/help' },
         ],
         mobileNavLinks: [
-          { text: 'About', link: 'https://ipfs.tech/#why' },
-          { text: 'Install', link: 'https://ipfs.tech/#install' },
+          { text: 'About', link: 'https://ipfs.tech/' },
+          { text: 'Community', link: 'https://ipfs.tech/community/' },
+          { text: 'Developers', link: 'https://ipfs.tech/developers/' },
           { text: 'Docs', link: 'https://docs.ipfs.tech/' },
-          { text: 'Team', link: 'https://ipfs.tech/team' },
           { text: 'Blog', link: '/zh-cn/' },
-          { text: 'Help', link: 'https://ipfs.tech/help' },
         ],
       },
     },

src/.vuepress/config/head.js

@@ -35,8 +35,7 @@ module.exports = [
     {
       defer: true,
       'data-domain': 'blog.ipfs.tech',
-      'data-api': 'https://proxy.daas.workers.dev/api/event',
-      src: 'https://proxy.daas.workers.dev/js/script.js',
+      src: 'https://plausible.io/js/plausible.js',
     },
   ],
 ].concat(favicons)

src/_blog/2023-09-amino-refactoring.md

@@ -0,0 +1,110 @@
+---
+title: Amino (the Public IPFS DHT) is getting a facelift
+description: 'The ProbeLab team is working on a major refactoring of the Public IPFS DHT (henceforth called Amino) and a new feature which will accelerate the provide operation by several orders of magnitude. Read through to find out the details and how to get involved.'
+author: ProbeLab
+date: 2023-09-26
+permalink: '/2023-09-amino-refactoring/'
+header_image: '/2023-09-amino-refactoring.png'
+tags:
+  - 'Amino'
+  - 'IPFS DHT'
+  - 'Reprovide Sweep'
+---
+
+Two major items are being announced in this blogpost, both of which are equally exciting and relate to “the Public IPFS DHT” (the [public Kademlia-based DHT](https://docs.ipfs.tech/concepts/dht/#dual-dht) that [Kubo (and other implementations) default to bootstrapping into](https://docs.ipfs.tech/how-to/modify-bootstrap-list/) with the libp2p protocol `/ipfs/kad/1.0.0`), which is henceforth going to be called **“Amino”**. The first relates to a major refactoring of the Amino codebase and the second is an optimization of the publish operation of the protocol, so that providing content to Amino is made much faster and resource-efficient.
+
+## Why Amino?
+
+The “Public IPFS DHT” is henceforth going to be called **“Amino”**. This follows along with the trend from 2022 in the IPFS ecosystem to use more precise language to create space for alternative options (i.e., other DHTs). Just as there isn’t one IPFS implementation, there isn’t one content routing system or DHT. “Amino” was chosen from Amino acids - the building block for larger, stronger structures, which is what we believe will happen with this network. There can be several IPFS DHT networks, and they can choose to borrow functionality from the “Amino” network. More context on the naming can be found [here](https://github.com/ipfs/ipfs/discussions/473).
+
+## Refactoring of `go-libp2p-kad-dht` codebase
+
+It has long been realized that the current go implementation of libp2p’s Distributed Hash Table (DHT), which is used by IPFS implementations like Kubo and other projects/platforms, is in need of a major revision. The problems that have been identified by core maintainers and community contributors alike can be summarised in the following:
+
+1. Several years of adding extra features to the codebase and iterations of core functionality have made the DHT faster and more efficient, but have also added substantially to its complexity. It has now become more **difficult to understand and make changes to the code**, which indirectly is pushing developers away from contributing to it.
+2. **Flaky tests due to concurrency issues**. Unit tests, which evaluate if the implementation is working as expected, are difficult to implement due to extensive parallelization of several parts of the code.
+3. Lack of unit tests in turn make it **hard to carry out performance evaluation tests**. This has recently resulted in performance evaluation results that are hard to understand or act upon - Bitswap’s `Provider Search` delay is a good example here [[link](https://github.com/ipfs/kubo/pull/9530)].
+4. The current implementation is carrying a **non-negligible amount of technical debt** that was acquired over the years. For instance, Kademlia should only handle Kademlia identifiers (256-bits bitstrings) internally, but it is currently using strings [[source](https://github.com/libp2p/go-libp2p-kad-dht/blob/b63ad6096833d36b365f1361edab871f6cdc283c/query.go#L83)].
+
+The [PL EngRes IPFS Stewards team](https://www.notion.so/IPFS-f3c309cecfd844e788d8b9e13472a97b?pvs=21) has been working on a **major refactoring of `go-libp2p-kad-dht`**. In this context, a new library, `go-libdht` defines the basic building blocks for implementing DHTs, and will be used by the refactored `go-libp2p-kad-dht`. The goal of the refactoring project is to address the above challenges. In particular,
+
+- make the code base easy to modify and improve by making it single-threaded.
+- allow for sequential, deterministic code execution, making debugging easier, testing more reliable and simulation/reproducibility possible and,
+- get rid of unnecessary code and complexity.
+
+### Expected Changes & Timeline
+
+The refactored codebase is being worked on in the [v2-develop branch of go-libp2p-kad-dht](https://github.com/libp2p/go-libp2p-kad-dht/tree/v2-develop). The current progress, next tasks and open issues can be found at this project board: [https://github.com/orgs/plprobelab/projects/1](https://github.com/orgs/plprobelab/projects/1). The refactored code is expected to be completed, tested and ready for integration into Kubo for further testing during the first half of October.
+
+Where possible, we aim to remain compatible with version 1. There are no breaking protocol changes planned, and we expect to be able to adhere to the standard Routing interface used by Kubo. The libp2p Kademlia implementation has been battle tested through many years of use, and we want to take advantage of the learnings from that real-world usage while improving the ergonomics and clarity of the code. However, we will be taking this opportunity to look closely at the current code interfaces and to propose improved or new ones.
+
+Most of the changes being made are internal to the operation of the DHT. We’re creating a new state machine oriented execution model that is very different to the existing implementation. This allows us to bound work and resources more cleanly and prioritize work performed more appropriately. Performance will also be different and, for the initial release, our goal is for this to be similar to the current codebase. However, we expect the new execution model will give us more scope for optimization in the future. Having better control over the scheduling of work will also allow the new implementation to continue to perform well under resource pressure and high load.
+
+## Making Reprovides to Amino lightning fast
+
+Content providers with a large number of CIDs to provide to the DHT have traditionally been facing difficulties. The current PUT operation in `go-libp2p-kad-dht` lacks resource efficiency. For every CID being reprovided, the provider performs a lookup and initiates a connection with the top 20 nearest peers *sequentially*. In practice, this means that if a peer needs to be contacted twice for two CIDs, the providing peer needs to open two connections to the same peer at different points in time within the same reprovide task.
+
+In turn, this results in significant bandwidth requirements and deters large content providers from advertising their content on Amino (the IPFS DHT) due to cost constraints. The sequential manner in which reprovides take place can result in content providers failing to refresh all content within the 48h provider record expiration interval [[link to source](https://github.com/libp2p/go-libp2p-kad-dht/blob/b63ad6096833d36b365f1361edab871f6cdc283c/providers/providers_manager.go#L38)][[link to spec](https://github.com/libp2p/specs/tree/master/kad-dht#content-provider-advertisement-and-discovery)], rendering the content inaccessible.
+
+Our approach is to optimize the provide process, making it much less resource intensive. This will pave the way for a significantly larger throughput in the number of "provides". 
+
+### High level design of `ReprovideSweep`
+
+The base premise of `ReprovideSweep` is that **all keys located in the *same keyspace region* are reprovided *all at once,** instead of sequentially,* which is currently the case. This is in contrast to the status quo of re-providing in the current IPFS DHT, where the provider record of each CID is sent out separately, though a new connection.
+
+Given that some large Content Providers are publishing way more CIDs than there are DHT Servers, by the [pigeonhole principle](https://en.wikipedia.org/wiki/Pigeonhole_principle) there must be DHT Servers that are allocated more than one Provider Record, by a particular Content Provider. The primary rationale is to send/re-provide all Provider Records allocated to the same DHT Server *******at once, instead of having to revisit the same server later on, re-establish a connection, and store the provider record*******.
+
+However, because sending multiple Provider Records requires a new RPC causing a breaking change, it isn’t trivial to send all Provider Records exactly *at once.* That said, the most expensive part in a (Re)Provide operation is the DHT walk to discover the right DHT Servers to store the Provider Records on, as well as opening new connections to these peers. Once these peers are known, and a connection is already open, the Content Provider can simply reuse the same connection to send multiple individual `Provide` requests, thereby avoiding breaking changes while still reaping performance gains.
+
+The `go-libp2p-kad-dht` DHT implementation must keep track of the CIDs that must be republished every `Interval` (let’s assume that all Provider Records are republished at the same frequency). The Kademlia identifiers of the CIDs to republish must be arranged in a [binary trie](https://github.com/guillaumemichel/py-binary-trie) to allow for faster access. As each Provider Record is replicated on 20 different DHT Servers, 20 DHT Servers in a close locality are expected to store the same Provider Records (this is not 100% accurate, but suffices for our high-level description here - we’ll publish all the details in a subsequent post, when the solution is in production).
+
+In a nutshell, the Content Provider will continuously lookup keys across the entire keyspace, hence “sweeping” the keyspace. For each key that is to be published, the Content Provider will find the 20 closest peers, and lookup in its “CIDs Republish Binary Trie” all Provider Records that would belong to those specific 20 remote peers. Doing this match-making exercise, content providers will be able to reprovide all provider records that correspond to a particular peer at once. Based on this logic, Content Providers are only limited by network throughput.
+
+You can watch a recording from [IPFS Thing 2023](https://2023.ipfs-thing.io/) explaining the concept in more detail [here](https://youtu.be/bXaL64fp55c?si=1LuukjErCG_bz02N).
+
+### `ReprovideSweep` Performance
+
+`ReprovideSweep` is not implemented yet, hence, we can only approximate its performance analytically. In the tables below we see that `ReprovideSweep` is improving performance significantly on all fronts and important metrics, assuming that the number of CIDs (`#CIDs`) that a provider wishes to publish is much larger than the number of DHT Server nodes in the network (`#DHT_SERVERs`), i.e. `#CIDs >> #DHT_SERVERs`:
+
+- The number of DHT Lookups is reduced from being equal to the number of CIDs to be published, down to 1/20th of the number of DHT Server nodes in the network.
+- The number of connections that need to be opened is also reduced and is equal to the number of DHT Server nodes (if the number of CIDs to be provided is much larger than the number of server nodes in the network).
+- As we see in the second table, assuming a network size of ~25k DHT Server nodes, the overall improvement in terms of ‘number of connections open’ and ‘number of DHT Lookups’ is significant reaching an improvement of ~800x for 1M CIDs.
+
+|  | Current Reprovide | Reprovide Sweep |
+| --- | --- | --- |
+| Number of DHT lookups | #CIDs | ~1/20 * #DHT_SERVERs |
+| Number of connections to open | 20 * #CIDs | #DHT_SERVERs |
+
+| #CIDs published | Improvement (#connections, #DHT Lookups) |
+| --- | --- |
+| > 1K | - |
+| 25K | 20x |
+| 100K | 80x |
+| 500K | 400x |
+| 1M | 800x |
+| 10M | 8’000x |
+
+### Expected Changes & Timeline
+
+We are very excited about this change because it will enable large content providers to start using the most resilient and decentralized component of the IPFS network.
+
+**This change is a client side optmization and doesn’t involve any protocol alteration.** As such, it allows users to immediately benefit from the feature. The interface between `go-libp2p-kad-dht` and [`boxo`](https://github.com/ipfs/boxo), which Kubo uses, must be updated to enable the DHT client to take on the responsibility of managing the reprovide operation.
+
+The PL EngRes IPFS Stewards team is currently working to define the spec for `ReprovideSweep`, which we hope to have ready in the beginning of October, and we anticipate rolling out this enhancement during Q4’23. We will update the community with a new blogpost or discussion forum post closer to the time. Until then, you can follow developments on this front through this GH issue: [https://github.com/libp2p/go-libp2p-kad-dht/issues/824](https://github.com/libp2p/go-libp2p-kad-dht/issues/824).
+
+## What’s next
+
+We believe the above lays the groundwork for more exciting DHT innovation ahead. We have some ideas that we’d love to be talking about and working with the community. We’re still figuring out the best place for this conversation, but subscribe [here](https://discuss.ipfs.tech/t/dht-discussion-and-contribution-opportunities-in-2023q4/16937) if you’re interested in learning about upcoming DHT discussion areas (e.g., at [LabWeek](https://labweek.plnetwork.io/)/[DevConnect](https://devconnect.org/), DHT working group). You can also join the team's Office Hours by subscribing at: [https://lu.ma/ipfs-network-measurements](https://lu.ma/ipfs-network-measurements).
+
+## How to get involved
+
+As always, help is more than welcome to accelerate development and make the design more robust through feedback. Here are ways you can get involved:
+
+- Github repository:
+    - DHT Refactoring: [https://github.com/plprobelab/go-kademlia/](https://github.com/plprobelab/go-kademlia/)
+    - Reprovide Sweep: [https://github.com/libp2p/go-libp2p-kad-dht/issues/824](https://github.com/libp2p/go-libp2p-kad-dht/issues/824)
+- Slack channel:
+    - `#probe-lab` in [FIL Slack](https://filecoin.io/slack) or [IPFS Discord](https://discord.gg/vj7qWuAyHY) (bridged channel), or
+    - `#kubo-boxo-dev` in FIL Slack
+- IPFS Discussion forum:
+    - DHT Refactoring and future planning: [https://discuss.ipfs.tech/t/dht-discussion-and-contribution-opportunities-in-2023q4/16937](https://discuss.ipfs.tech/t/dht-discussion-and-contribution-opportunities-in-2023q4/16937)

src/_blog/2023-brave-infobar.md

@@ -0,0 +1,26 @@
+---
+title: Brave Browser's New IPFS Infobar
+description: 'We’re excited to share a new IPFS-related feature that appears in the most recent version of Brave.'
+date: 2023-09-25
+header_image: '/braveinfobar2.png'
+tags:
+- brave
+- browsers
+---
+
+We’re excited to share a new IPFS-related feature that appears in the most recent version of [Brave’s web browser](https://brave.com/). A new IPFS Infobar will appear at the top of the browser when you visit an IPFS compatible resource such as a [CID on a public gateway](https://docs.ipfs.tech/how-to/address-ipfs-on-web/#http-gateways)  or a website with a [DNSLink](https://docs.ipfs.tech/concepts/dnslink/). 
+
+By using the IPFS Infobar, you can choose whether you would like to switch to loading the IPFS version of the content. Selections can be made to always load via IPFS or only load it in a specific instance.
+
+![](../assets/brave_infobar_2.jpg)
+![](../assets/brave_infobar_3.png)
+
+This new feature will increase visibility of IPFS content when it exists and contribute to greater awareness for the benefits that can be had from utilizing content addressing.
+
+Brave’s IPFS Infobar is a small but mighty new feature that we are excited to see in the wild!
+
+In addition to the Infobar, there are more tools currently being developed for [Brave](https://brave.com/) by others such as [David Justice](https://github.com/JusticeEngineering) that are worth noting. Some of the prototypes include: Markdown/Wysiwyg webpage creator, Link In Bio/Link List site creator, and the ability to password protect webpages with many more ideas in the works.
+
+[https://github.com/JusticeEngineering/markdown-publish](https://github.com/JusticeEngineering/markdown-publish)
+ 
+[https://github.com/JusticeEngineering/link-list](https://github.com/JusticeEngineering/link-list)

src/_blog/2023-introducing-the-ecosystem-working-group.md

@@ -0,0 +1,30 @@
+---
+title: Introducing the IPFS Ecosystem Working Group
+description: 'Nurturing a vibrant and sustainable IPFS ecosystem.'
+author: The Ecosystem Working Group
+date: 2023-09-05
+permalink: '/2023-introducing-the-ecosystem-working-group/'
+header_image: ''
+tags:
+  - 'Ecosystem'
+  - 'Working Group'
+---
+
+Since its initial release over 9 years ago, IPFS has been stewarded by a variety of teams and individual contributors, both within and outside of Protocol Labs. More recently though, it has lacked a dedicated team focused on nothing other than the success of the IPFS ecosystem. It is with this reality in mind that we are excited to announce the formation of **the brand new IPFS Ecosystem Working Group!**
+
+At launch, the IPFS Ecosystem WG consists of Protocol Labs contributors, but we are forming with the explicit purpose of spinning out into our own independent entity over the coming months. We believe that this working group and its autonomy will be critical in helping propel IPFS toward a better and even brighter future. 
+
+Initially, we have four core goals:
+
+1. Foster a thriving ecosystem by advocating for IPFS,
+2. Build bridges between IPFS and other ecosystems that could benefit from content addressing,
+3. Grow the community and develop strong and durable community ownership of the IPFS project as a public good, and
+4. Spin out from Protocol Labs into a self-sustaining organization that can support the IPFS community and build robust, effective governance for the protocol.
+
+The future of IPFS requires greater degrees of decentralization, so you can expect other IPFS-focused teams to begin spinning out from Protocol Labs in the future as well. 
+
+As we continue to make progress towards these goals, we will provide updates and work in the open so as to keep the entire community in-the-loop with what we’re doing. A thriving ecosystem requires care and attention, and we believe that this new initiative and nimble team will be able to deliver on exactly that. But our work is only part of the story: community ownership means that your voice as IPFS users, operators, or contributors needs to be heard just as much as ours. 
+
+So if you have comments, questions, or concerns, then please join the discussion in the comments section below, via the [Ecosystem section of the IPFS Forums](https://discuss.ipfs.tech/c/communities/ecosystem/15), or the various chat links that follow – together let’s work on making IPFS thrive!
+
+[Forums](https://discuss.ipfs.tech/c/communities/ecosystem/15) | [Discord](https://discord.com/channels/806902334369824788/1146489977174233098) | [Slack](https://filecoinproject.slack.com/archives/C05PGBP697E) | [Matrix](https://app.element.io/#/room/#ipfs-ecosystem:ipfs.io)

src/_blog/2023-ipfs-connect-istanbul.md

@@ -0,0 +1,46 @@
+---
+title: Announcing IPFS Connect Istanbul 2023
+description: 'Join the IPFS Community for a full day of workshops, lightning talks, and demos showcasing technology, tools, and innovative projects in the IPFS ecosystem.'
+date: 2023-09-20
+header_image: '/ipfsconnect2023.jpg'
+tags:
+- events
+---
+
+**IPFS Connect** is a community-run regional conference bringing together all of the builders and ecosystems that rely on and use IPFS as the most widely used decentralized content addressing protocol for files and data. This year's event is happening alongside Devconnect and LabWeek23 in **Istanbul, Turkey on November 16**. Join the IPFS Community for a full day of workshops, lightning talks, and demos showcasing technology, tools, and innovative projects in the IPFS ecosystem. 
+
+There are several opportunities for you to get involved with this event whether you're a business, organization, or individual.
+
+## Present to a large community of builders at IPFS Connect
+
+We're planning a full day of talks & workshops to prepare and inspire builders from around the globe that are attending Devconnect. This includes large ecosystems and communities that rely on and integrate with IPFS, as well as individual builders joining to hack at ETHGlobal Hackathon that starts the day after IPFS Connect.
+
+### Presentation & Workshop Types
+- Lightning talks & demos: short talks presenting your service, code, or app, designed to inspire, get signups, or talk about how you built it using IPFS.
+- Workshops: we have 2 dedicated workshop spaces that will be running all day. Run a workshop session with attendees walking through your -solution so they're ready to hack the next day.
+- Discussion: run a collaborative discussion on topics of interest - privacy, self hosting, devops best practices, decentralized data compliance, etc.
+- Full talks: present in one of two theater spaces, with professional video recording. We want to hear about your technical how-to, user stories, and other talks that inspire and educate.
+
+Speakers receive a free ticket to the event, as well as discount codes to invite their community
+
+<a href="https://cfp.ipfsconnect.org/ipfsconnect-istanbul/cfp" class="cta-button">Submit a presentation or proposal</a>
+
+## Attend and connect with other community members
+
+Tickets for IPFS Connect are on sale now, so you can register and buy early bird tickets to get full access to the day's events and opportunities: [https://istanbul2023.ipfsconnect.org](https://istanbul2023.ipfsconnect.org)
+
+<a href="https://istanbul2023.ipfsconnect.org" class="cta-button">Register today</a>
+
+## Sponsor the event to reach your target audience
+
+You can learn more about multiple sponsorship opportuntities [via the sponsor deck here.](https://docs.google.com/presentation/d/1UMbRP5pYHDL5TluzBWUuqlo6DB6F1G8bgUZhMa_w_Pc/view#slide=id.p)
+
+**Developers:** 
+- Beginners to experts in IPFS
+- Interested in adding IPFS to their Web3 stacks so that dapp front ends are decentralized and want to use off-chain files and data to build more usable apps
+
+**Startups, DAOs, Sovereign Chains:**
+- Select technology and service providers building on the IPFS tech stack combined with other Web3 components
+- Exploring novel use cases for IPFS including provenance, computation, identity, and more
+
+<a href="https://docs.google.com/presentation/d/1UMbRP5pYHDL5TluzBWUuqlo6DB6F1G8bgUZhMa_w_Pc/view#slide=id.p" class="cta-button">Learn more about sponsoring</a>

src/_blog/ipfs-events-2024-survey.md

@@ -0,0 +1,20 @@
+---
+title: Take the IPFS Events 2024 Survey Today!
+description: 'We need your help! Make your voice heard about upcoming IPFS Events.'
+date: 2023-09-18
+tags:
+- survey
+- events
+---
+
+## **We need your help! Make your voice heard about upcoming IPFS Events 📆**
+
+Each year, several different IPFS events and gatherings are held at different locations to make space for the community to socialize, learn, and grow together. Many of you have been eagerly awaiting more information about when the next events will be, and we’re excited to begin sharing some of those details with you starting today!
+
+**IPFS Camp** will take place in **Spring 2024**! IPFS Camp is a large in-person gathering for the entire IPFS community: devs, operators, implementers, researchers – and you!
+
+**IPFS Thing** is targeted for **Fall 2024**! IPFS Thing is a week-long gathering for the IPFS implementors community. Everything from talks, workshops, discussion circles, hacking time, and more — all focused on advancing IPFS implementations.
+
+We are currently in the middle of sourcing venues for both events and would love to hear your feedback on where we should be looking and why. [Submit your feedback via the following survey](https://docs.google.com/forms/d/e/1FAIpQLScNP2NKgjVBu80IygfioeTH32aCMYASLBrlQ7q05ub3choHKQ/viewform) **by September 25 at 11:59pm PST** to make sure that you’re voice is heard!
+
+<a href="https://docs.google.com/forms/d/e/1FAIpQLScNP2NKgjVBu80IygfioeTH32aCMYASLBrlQ7q05ub3choHKQ/viewform" class="cta-button">Fill out the survey</a>

src/_blog/ipfs-uri-support-in-curl.md

@@ -0,0 +1,195 @@
+---
+title: IPFS URL support in CURL
+description: 'CURL 8.4.0 shipped with built-in support for ipfs:// and ipns:// addresses.'
+author: Mark Gaiser
+date: 2023-10-16
+permalink: '/ipfs-uri-support-in-curl/'
+header_image: '/curl.png'
+tags:
+  - 'community'
+  - 'URI'
+  - 'URL'
+  - 'HTTP'
+  - 'curl'
+---
+
+# `ipfs://` URL support in `curl`
+
+[CURL 8.4.0](https://github.com/curl/curl/releases/tag/curl-8_4_0) shipped with built-in support for `ipfs://` and `ipns://` addresses.
+
+This enables `curl` to seamlessly integrate with the user's preferred [IPFS gateway](https://docs.ipfs.tech/reference/http/gateway/) through the `IPFS_GATEWAY` environment variable or a `gateway` file. Best of all, these capabilities are available for immediate use today:
+
+```bash
+$ export IPFS_GATEWAY="http://127.0.0.1:8080" # local (trusted) gateway provided by ipfs daemon like Kubo
+$ curl ipfs://bafkreih3wifdszgljcae7eu2qtpbgaedfkcvgnh4liq7rturr2crqlsuey
+hello from IPFS
+```
+
+In this blog post, we will:
+- explore the journey of implementing IPFS URI support in CURL,
+- delve into the mechanics of [how CURL locates an IPFS gateway](#how-does-curl-find-an-ipfs-gateway),
+- learn how to be immune to [malicious gateways](#malicious-gateways-and-data-integrity),
+- and finally, provide [practical CURL examples](#curl-examples) for leveraging IPFS URLs for either deserialized or verifiable responses.
+
+## A brief history
+
+Supporting IPFS in CURL has been attempted [before](https://github.com/curl/curl/pull/8468) as a CURL library feature. Some discussions lead to a belief that this should be implemented in the CURL tool itself, not its library. A renewed [implementation attempt](https://github.com/curl/curl/pull/8805) took the tool-side approach which ultimately was accepted and is available right now in CURL 8.4.0!
+
+The support of IPFS in CURL is effectively consisting of two implementation details.
+
+1. CURL tries to find a locally installed or [configured gateway](#how-does-curl-find-an-ipfs-gateway).
+2. It then rewrites an `ipfs://bafybeigagd5nmnn2iys2f3doro7ydrevyr2mzarwidgadawmamiteydbzi` to a gateway URL. This is how curl handles it internally, you see nothing of this URL rewriting.
+
+If you have IPFS installed locally then running `curl ipfs://` will Just Work™. If not, CURL will return an error with details about how to set up the gateway preference. This ensures the user agency is respected, no third-party gateway is used as implicit default.
+
+## Why `ipfs://` URL support is so important?
+
+Why isn't `https://ipfs.io/ipfs/bafybeigagd5nmnn2iys2f3doro7ydrevyr2mzarwidgadawmamiteydbzi` equally acceptable?
+Or why isn't a local URL `http://localhost:8080/ipfs/bafybeigagd5nmnn2iys2f3doro7ydrevyr2mzarwidgadawmamiteydbzi` fine?
+
+Both addresses are tied to a specific _location_.
+
+IPFS is a modular suite of protocols purpose built for the organization and transfer of [content-addressed](https://docs.ipfs.tech/concepts/content-addressing) data. It shouldn't matter where the content is. Content Identifier ([CID](https://docs.ipfs.tech/concepts/glossary/#cid)) is all that is required. The "where" part is implementation detail an IPFS system takes care of. Hardcoding a location in addition to a CID (like a specific HTTP gateway) limits end users to IPFS resources available through that one specific, centralized point of entry.
+
+If we pull the URL apart we see:
+
+![](../assets/ipfs_uri_where_protocol_what.png)
+
+Users of the IPFS system should not care about the _where_ part, nor be coerced to use a specific, hard-coded entry point into the system.
+
+Public gateways like `ipfs.io` are always owned by some entity and could get censored or shut down at any time. Many gateways will not allow playback of deserialized videos or only respond to CIDs from allowlists to reduce costs. Other gateways will block specific CIDs from resolving in specific jurisdictions for legal reasons. Community-run public gateways will have limits and throttle usage.
+
+These are not limitations of IPFS but purely a limitation a specific gateway has set through custom configuration. IPFS user should always have ability to avoid such limitations if they choose to self-host and [run their own IPFS node with a local gateway](https://docs.ipfs.tech/install/).
+
+<!-- TODO: remove? feels like duplicate of we already say in this and "malicious" sections, but mentioning ffmpeg blogpost feels like something we should  keep somewhere
+
+This is why running a local node (and therefore a local gateway, it's part of a node) is so important. Even though you still effectively use `http://localhost:8080` as gateway, it's hosted by you locally backed by the many peers your node is connected with. Your experience in using IPFS is going to be best and fastest with a local node. Even when your local gateway isn't working it's easy for you to restart your node and get that gateway back and running. You can't do that on public gateways that you don't control.
+
+One of the many reasons why we're putting in the effort to make applications recognize IPFS URIs (like [ffmpeg](https://blog.ipfs.tech/2022-08-01-ipfs-and-ffmpeg/)) `ipfs://bafybeigagd5nmnn2iys2f3doro7ydrevyr2mzarwidgadawmamiteydbzi` is to let the application in the background find that gateway you're running and giving you the freedom of being truly distributed! This also allows url's to be shared as IPFS url's (like `ipfs://bafybeigagd5nmnn2iys2f3doro7ydrevyr2mzarwidgadawmamiteydbzi`) without any trace of a (central) gateway and bring us one step closer to a distributed world where it doesn't matter anymore where that data is located.
+
+-->
+
+## How does CURL find an IPFS Gateway?
+
+Any IPFS implementation that has support for [IPIP-280](https://github.com/ipfs/specs/pull/280) exposes an IPFS gateway that CURL (and [ffmpeg](https://blog.ipfs.tech/2022-08-01-ipfs-and-ffmpeg/)) can use. At the moment of writing that's just [Kubo](https://github.com/ipfs/kubo/releases).
+
+CURL 8.4.0 and greater looks for a gateway in the following order:
+
+1. `IPFS_GATEWAY`, if set it's used.
+2. The `--ipfs-gateway` CLI argument.
+3. The `~/.ipfs/gateway` file, where it reads the first line.
+
+If a gateway hint is found at any of those places, and if that is a valid HTTP URL, then CURL will use it. If not, then you'll be getting an error message pointing to the [CURL documentation related to IPFS](https://curl.se/docs/ipfs.html) to help you further.
+
+One can specify any IPFS gateway that is in compliance with [Gateway Specifications](https://specs.ipfs.tech/http-gateways/). It is highly recommended to use a local gateway, as it provides the best security guarantees.
+
+## Malicious gateways and data integrity?
+
+Requesting deserialized responses and delegating hash verification to a third-party gateway comes with risks. It is possible that a public gateway is malicious. Or, that a well-known and respected gateway gets hacked and changed to return payload that does not match requested CID. How can one protect themselves against that?
+
+If deserialized responses are necessary, one should run their own gateway in a local, controlled environment. Every block of data retrieved though self-hosted IPFS gateway is verified to match the hash from CID. For the maximum flexibility and security, find an implementation that provides the gateway endpoint (i.e. [Kubo](https://docs.ipfs.tech/install/command-line/)) and run it yourself!
+
+When using a third-party gateway that one can't fully trust, the only secure option is to [request verifiable response types](https://docs.ipfs.tech/reference/http/gateway/#trustless-verifiable-retrieval) such as [application/vnd.ipld.raw](https://www.iana.org/assignments/media-types/application/vnd.ipld.raw) (a single block) or [application/vnd.ipld.car](https://www.iana.org/assignments/media-types/application/vnd.ipld.car) (multiple blocks in CAR archive). Both allow to locally verify if the data returned by gateway match the requested CID, removing the surface for [Man-in-the-middle attacks](https://en.wikipedia.org/wiki/Man-in-the-middle_attack).
+
+## CURL Examples
+
+### Deserialized responses
+
+::: callout
+
+By default, a trusted local gateway acts as a bridge between traditional HTTP clients and IPFS.
+
+It performs necessary hash verification, UnixFS _deserialization_ and return reassembled files to the client, as if they were stored in a traditional HTTP server. This means all validation happens on the gateway, and clients trust that the gateway is correctly validating content-addressed data before returning it to them.
+
+:::
+
+#### Downloading a file from IPFS with CURL
+
+```bash
+$ curl ipfs://bafkreih3wifdszgljcae7eu2qtpbgaedfkcvgnh4liq7rturr2crqlsuey -o out.txt
+```
+
+If curl responds with `curl: IPFS automatic gateway detection failure`, make sure `IPFS_GATEWAY` is set (see examples below).
+
+#### Explicitly specifying a gateway
+
+To use local gateway on custom port 48080:
+
+```bash
+$ export IPFS_GATEWAY=http://127.0.0.1:48080
+$ curl ipfs://bafkreih3wifdszgljcae7eu2qtpbgaedfkcvgnh4liq7rturr2crqlsuey
+hello from IPFS
+```
+
+When setting environment variable is not feasible, one can use `--ipfs-gateway` instead:
+
+```bash
+$ curl --ipfs-gateway http://127.0.0.1:48080 ipfs://bafkreih3wifdszgljcae7eu2qtpbgaedfkcvgnh4liq7rturr2crqlsuey
+hello from IPFS
+```
+
+#### Following subdomain redirects
+
+::: callout
+
+By default, the URL resolution in `curl` does not follow HTTP redirects and assumes the endpoint implements deserializing [path gateway](https://specs.ipfs.tech/http-gateways/path-gateway/), or at the very least, the [trustless gateway](https://specs.ipfs.tech/http-gateways/trustless-gateway/).
+When pointing `curl` at a [subdomain gateway](https://specs.ipfs.tech/http-gateways/subdomain-gateway) (like `https://dweb.link` or the `http://localhost:8080` provided by a [local Kubo node](https://docs.ipfs.tech/how-to/command-line-quick-start/)) one has to pass `-L` in the curl command to follow the redirect.
+
+:::
+
+```bash
+$ IPFS_GATEWAY=https://localhost:8080 curl -s -L ipfs://bafkreih3wifdszgljcae7eu2qtpbgaedfkcvgnh4liq7rturr2crqlsuey
+hello from IPFS
+```
+
+#### Piping and streaming responses
+
+Deserialized response returned by CURL can be piped directly to a video player:
+
+```
+$ curl ipfs://bafybeigagd5nmnn2iys2f3doro7ydrevyr2mzarwidgadawmamiteydbzi | ffplay -
+```
+
+### Verifiable responses
+
+::: callout
+
+By explicitly requesting [application/vnd.ipld.raw](https://www.iana.org/assignments/media-types/application/vnd.ipld.raw) (a block) or [application/vnd.ipld.car](https://www.iana.org/assignments/media-types/application/vnd.ipld.car) (a stream of blocks) responses, by means defined in [Trustless Gateway Specification](https://specs.ipfs.tech/http-gateways/trustless-gateway/), the user is able to fetch raw content-addressed data and [perform hash verification themselves](https://docs.ipfs.tech/reference/http/gateway/#trustless-verifiable-retrieval).
+
+:::
+
+#### Fetching and verifying a directory from an untrusted gateway
+
+Requesting [trustless and verifiable](https://docs.ipfs.tech/reference/http/gateway/#trustless-verifiable-retrieval) CAR response via `Accept` HTTP header:
+
+```bash
+$ export IPFS_GATEWAY="https://ipfs.io" # using untrusted public gateway
+$ curl -H "Accept: application/vnd.ipld.car" "ipfs://bafybeiakou6e7hnx4ms2yangplzl6viapsoyo6phlee6bwrg4j2xt37m3q" > dag.car
+```
+
+Then, CAR can be moved around and imported into some other IPFS node:
+
+```bash
+$ ipfs dag import dag.car
+```
+
+or verified and unpacked locally, without having to run a full IPFS node, with tools like [go-car](https://github.com/ipld/go-car/tree/master/cmd/car#readme) or [ipfs-car](https://www.npmjs.com/package/ipfs-car):
+
+```
+$ npm i -g ipfs-car
+$ ipfs-car unpack dag.car --output dag.out
+$ ls dag.out
+1007 - Sustainable - alt.txt
+1007 - Sustainable - transcript.txt
+1007 - Sustainable.png
+```
+
+## What's next?
+
+More places supporting IPFS addresses. Everyone can integrate `ipfs://` and `ipns://` URL support into their application. See specifications proposed in [IPIP-280](https://github.com/ipfs/specs/pull/280) for technical details. We are [tracking potential project](https://github.com/ipfs/integrations/issues) where an integration makes sense! If you feel up to the challenge, don't hesitate to drop a comment in one of the [potential projects](https://github.com/ipfs/integrations/issues) for IPFS URL integration or find us on:
+
+* [Matrix](https://matrix.to/#/#ipfs-space:ipfs.io), [Discord](https://discord.com/invite/ipfs) or [Slack](https://filecoin.io/slack)
+* [Discussion Forum](https://discuss.ipfs.tech/)
+
+Or one of the other many places where the [IPFS community](https://docs.ipfs.tech/community/) is active.
+

src/_blog/newsletter-196.md

@@ -0,0 +1,73 @@
+---
+title: Welcome to IPFS News 196!
+description: Featuring news about a resilient and fully-automated infrastructure to monitor the performance of the IPFS network.
+author: ''
+date: 2023-08-09
+permalink: "/newsletter-196"
+translationKey: ''
+header_image: "/ipfsnews.png"
+tags:
+- newsletter
+---
+
+## **An Observatory for the IPFS Network 🔭**
+
+We're excited to share that the ProbeLab team has worked hard over the past year to build a resilient and fully-automated infrastructure to monitor the performance of core IPFS stack protocols. The debut of this new measurement platform is big news, and you can learn all about it in a new post on the IPFS blog.
+
+<a href="https://blog.ipfs.tech/2023-ipfs-observatory/" class="cta-button">Read the blog post</a>
+
+![](../assets/probelab.png)
+
+## **Brand New on IPFS ✨**
+
+[A Rusty Bootstrapper](https://blog.ipfs.tech/2023-rust-libp2p-based-ipfs-bootstrap-node/)
+
+- As of July 13, 2023, one of the four "public good" IPFS bootstrap nodes operated by Protocol Labs has been running rust-libp2p-server instead of Kubo, which uses go-libp2p. rust-libp2p-server is a thin wrapper around rust-libp2p. We run both Kubo and rust-libp2p-server on IPFS bootstrap nodes to increase resilience. [Read more about it on the IPFS blog!](https://blog.ipfs.tech/2023-rust-libp2p-based-ipfs-bootstrap-node/)
+
+[Dogfooding Announcement: IPFS-Companion Manifest v3 Changes](https://discuss.ipfs.tech/t/announcing-ipfs-companion-mv3-rc-beta/16442/7)
+
+- The PL EngRes Ignite team has achieved a significant milestone – the completion of IPFS-Companion Manifest v3 changes! IPFS-Companion is browser extension that makes browsing the IPFS web simpler. These changes promise to greatly enhance compatibility with browsers going forward and offer performance improvements. [Read about it and get involved here!](https://discuss.ipfs.tech/t/announcing-ipfs-companion-mv3-rc-beta/16442/7)
+
+[IPFS Events Planning Meeting](https://lu.ma/ipfseventsplanning)
+
+- The events team is kicking off a new Events Planning Call today. If you're interested in joining or participating, you can find these meetings on the [IPFS Community Calendar](lu.ma/ipfs), or you can register directly at [lu.ma/ipfseventsplanning](lu.ma/ipfseventsplanning). Today's agenda will be to discuss timing for IPFS Camp and Thing for 2024. Timing will affect the locations that make the shortlist. [Join us here!](https://lu.ma/ipfseventsplanning)
+
+[Boxo v0.11.0](https://github.com/ipfs/boxo/blob/release-v0.11.0/CHANGELOG.md)
+
+## **Around the Ecosystem 🌎**
+
+[Guide: Setting Up a Website on the Distributed Web using Distributed Press](https://medium.com/@lindsay_walker/setting-up-a-website-on-the-distributed-web-7eae22594303)
+
+- Distributed Press is a tool used to easily host content on distributed, peer-to-peer protocols such as IPFS and Hypercore, using open source tools created by the Distributed Press project. Publishing a static site on distributed protocols means that your website is more resilient and likely to stand the test of time. [Learn how to do it here!](https://medium.com/@lindsay_walker/setting-up-a-website-on-the-distributed-web-7eae22594303)
+
+[Anytype: A private hub for all your data](https://anytype.io/)
+
+- Meet Anytype, a private hub for all your data: docs, tasks, files, bookmarks, contacts and more. It’s built on a new architecture that protects your privacy and data sovereignty, even when working across devices. Use it to create elegant dashboards, documents, and knowledge graphs. [Try it out here!](https://anytype.io/)
+
+[Fleek Network announces new edge platform](https://twitter.com/fleek_net/status/1685997861907890176)
+
+- Fleek Network's new platform utilizes IPFS/IPLD as the addressability and performance layer of data on the network. [Learn more here!](https://twitter.com/fleek_net/status/1685997861907890176)
+
+[Admarus: A Peer-to-Peer Search Engine for IPFS](https://blog.admarus.net/blog/mvp-release/)
+
+- A decentralized search engine for the decentralized web (specifically, IPFS). [Check it out here!](https://blog.admarus.net/blog/mvp-release/)
+
+[Beloga: A Decentralized Blogging Platform](https://discuss.ipfs.tech/t/beloga-decentralized-blogging-platform-powered-by-ipfs/16727)
+
+- This new blogging platform has IPFS at its core with posts being securely stored and decentralized, making them tamper-proof and censorship-resistant. [See it for yourself here!](https://discuss.ipfs.tech/t/beloga-decentralized-blogging-platform-powered-by-ipfs/16727)
+
+[Filebase introduces custom comain support for dedicated IPFS gateways](https://filebase.com/blog/introducing-custom-domain-support-for-dedicated-ipfs-gateways/)
+
+- With the introduction of custom domain support, users can now attach their domain names to their dedicated gateways, bolstering their brand consistency and accessibility. [Learn more about it in this blog post announcement!](https://filebase.com/blog/introducing-custom-domain-support-for-dedicated-ipfs-gateways/)
+
+[IPFSnodes.com](https://ipfsnodes.com/)
+
+- A community created dashboard with lots of data and information about the IPFS network and its nodes. [Take a look at it here!](https://ipfsnodes.com/)
+
+[Open Data Hackathon](https://www.encode.club/open-data-hack)
+
+- This upcoming hackathon features a $1,000 IPFS bounty. [Learn more and get involved here!](https://www.encode.club/open-data-hack)https://www.encode.club/open-data-hack
+
+[The Evolution of Filecoin and IPFS: An Overview of Challenges and Future Opportunities](https://medium.com/filemarket-xyz/the-evolution-of-filecoin-and-ipfs-an-overview-of-challenges-and-future-opportunities-795ce237c4b6)
+
+- A new article on FileMarket about the evolution of Filecoin and IPFS that is based on an AMA with Juan Benet during Filecoin Unleashed Paris 2023. Read through it here!

src/_blog/newsletter-197.md

@@ -0,0 +1,52 @@
+---
+title: Welcome to IPFS News 197!
+description: Featuring an announcement about the new Ecosystem Working Group and Kubo v0.22.0
+author: ''
+date: 2023-09-12
+permalink: "/newsletter-197"
+translationKey: ''
+header_image: "/ipfsnews.png"
+tags:
+- newsletter
+---
+
+## **Introducing the Ecosystem Working Group 🔭**
+
+Since its initial release over 9 years ago, IPFS has been stewarded by a variety of teams and individual contributors, both within and outside of Protocol Labs. More recently though, it has lacked a dedicated team focused on nothing other than the success of the IPFS ecosystem. It is with this reality in mind that we are excited to announce the formation of **[the brand new IPFS Ecosystem Working Group](https://blog.ipfs.tech/2023-introducing-the-ecosystem-working-group/)**!
+
+<a href="https://blog.ipfs.tech/2023-introducing-the-ecosystem-working-group/" class="cta-button">Read the blog post</a>
+
+## **Brand New on IPFS ✨**
+
+[Kubo v0.22.0](https://github.com/ipfs/kubo/releases/tag/v0.22.0)
+
+- Gateway: support for order= and dups= parameters (IPIP-412)
+- ipfs name publish now supports V2 only IPNS records
+- IPNS name resolution has been fixed
+- go-libp2p v0.29.0 update with smart dialing
+
+[IPFSConnect Istanbul](https://istanbul2023.ipfsconnect.org/)
+
+- Have you checked out [IPFSConnect](https://twitter.com/IPFSConnect) yet? It's a community-run meetup of developers and designers building on top of IPFS. Join us in Istanbul on Nov 16th for a day of workshops + talks! [Learn more here!](https://istanbul2023.ipfsconnect.org/)
+
+## **Around the Ecosystem 🌎**
+
+[LabWeek23 is happening November 13-17](https://23.labweek.io/)
+
+- Have you booked your travel yet? [LabWeek23](https://23.labweek.io/) is happening in Istanbul, Türkiye, from November 13-17, alongside Devconnect! This is your chance to connect and collaborate with visionaries and teams that are domain leaders in ZK Proofs, AI and blockchain, DeSci, decentralized storage, gaming in Web3, public goods funding, cryptoeconomics, and much more. [Learn more about it here!](https://23.labweek.io/)
+
+[A Beginner's Guide to IPFS Content Addressing](https://filebase.com/blog/a-beginners-guide-to-ipfs-content-addressing/)
+
+- Learn how to harness the power of the InterPlanetary File System for seamless content distribution by checking out this comprehensive guide to IPFS content addressing by Filebase. [Read it here!](https://filebase.com/blog/a-beginners-guide-to-ipfs-content-addressing/)
+
+[Fleek's new app is in closed alpha](https://blog.fleek.xyz/post/fleekxyz-alpha-release/)
+
+- "The day is finally here–the first step of the new Fleek, both app and brand ⚡ Let’s set the stage: This is not the full release of the new Fleek app. Today marks the start of our initial closed testing phase, leading up to an open testing period, and later in September, the full v1 release of the new app." [Learn more in this blog post!](https://blog.fleek.xyz/post/fleekxyz-alpha-release/)
+
+[New git-ipfs remote bridge](https://twitter.com/momack28/status/1697072752266706979?s=20)
+
+- "Love git and IPFS? There's a new git-ipfs remote bridge that lets you snapshot new git releases to IPFS for self-hosting, immutable versioning, and decentralized replication. Go InterPlanetary!" [Check it out here!](https://github.com/ElettraSciComp/Git-IPFS-Remote-Bridge)
+
+[Encrypted file support will be added to Cedalio soon](https://medium.com/@cedalio/product-update-uploading-files-has-never-been-easier-7b328def728a)
+
+- "Introducing the ability to define file types within your GraphQL schema, while we handle the rest. To stay in sync with our company core values, we store files in IPFS, a decentralized peer-to-peer protocol for storing and sharing files across a distributed network. As of now, files stored in IPFS are not encrypted; however, we’re excited to announce that support for encryption will be added in early October." [Learn more via their product update!](https://medium.com/@cedalio/product-update-uploading-files-has-never-been-easier-7b328def728a)

src/_blog/newsletter-198.md

@@ -0,0 +1,78 @@
+---
+title: Welcome to IPFS News 198!
+description: Featuring announcements about Brave's New IPFS Infobar, Amino, and IPFS Connect!
+date: 2023-10-03
+permalink: "/newsletter-198"
+header_image: "/ipfsnews.png"
+tags:
+- newsletter
+---
+
+## **IPFS Connect 2023 Istanbul 🔭**
+
+IPFS Connect is a community-run regional conference bringing together all of the builders and ecosystems that rely on and use IPFS as the most widely used decentralized content addressing protocol for files and data. This year's event is happening alongside Devconnect and LabWeek23 in Istanbul, Turkey on November 16. Join the IPFS Community for a full day of workshops, lightning talks, and demos showcasing technology, tools, and innovative projects in the IPFS ecosystem.
+
+There are several opportunities for you to get involved with this event whether you're a business, organization, or individual.
+
+<a href="https://blog.ipfs.tech/_2023-ipfs-connect-istanbul/" class="cta-button">Read the blog post</a>
+
+## **Brand New on IPFS ✨**
+
+[Brave Browser's New IPFS Infobar](https://blog.ipfs.tech/_2023-brave-infobar/)
+
+- We’re excited to share a new IPFS-related feature that appears in the most recent version of Brave’s web browser. A new IPFS Infobar will appear at the top of the browser when you visit an IPFS compatible resource such as a CID on a public gateway or a website with a DNSLink. [Learn more here!](https://blog.ipfs.tech/_2023-brave-infobar/)
+
+[IPFS support was merged into curl](https://twitter.com/bmann/status/1705572964068930010?s=20)
+
+- Thanks to the hard work and dedication of [Mark Gaiser](https://github.com/markg85), IPFS support was recently [merged into curl](https://github.com/curl/curl/pull/8805#issuecomment-1732260385), a command line tool and library for transferring data with URL syntax. More information and an official announcement are to come, but we're excited for this important milestone. IPFS is already in the curl documentation: [https://curl.se/docs/ipfs.html](https://curl.se/docs/ipfs.html)
+
+[Amino (the Public IPFS DHT) is getting a facelift](https://blog.ipfs.tech/2023-09-amino-refactoring/)
+
+- [Read the blog post](https://blog.ipfs.tech/2023-09-amino-refactoring/) to learn all the details and follow this discussion forum thread if you want to be kept up-to-date about further developments: [https://discuss.ipfs.tech/t/dht-discussion-and-contribution-opportunities-in-2023q4/16937/2](https://discuss.ipfs.tech/t/dht-discussion-and-contribution-opportunities-in-2023q4/16937/2)
+
+[The ProbeLab team needs your help — fill out this survey!](https://tally.so/r/npoo6q)
+
+- The ProbeLab team developed tools and infrastructure to capture the metrics you see at [https://probelab.io/](https://probelab.io). We want to expand the list of metrics we capture and build new open-source tools that will help protocol designers and application developers get a better idea of where the performance of their application can improve. This is your chance to influence where our team focuses next. [Please fill in the survey and let us know if and how you would be interested to contribute to this line of work.](https://tally.so/r/npoo6q)
+
+[awesome-ipfs reboot](https://awesome.ipfs.tech/)
+
+- After lying dormant for many months, the awesome-ipfs website has been cleaned up and rebooted. [Check out the updated version here!](https://awesome.ipfs.tech/)
+
+[IPFS & Filecoin Ecosystem Roundup](https://www.youtube.com/watch?v=bdOPPnuZnhw)
+
+- The September Filecoin & IPFS Ecosystem Roundup is online! Check out the video for the latest updates, developments, and insights straight from the community. [Watch it here!](https://www.youtube.com/watch?v=bdOPPnuZnhw)
+
+## **Around the Ecosystem 🌎**
+
+[IPFS on AWS, Part 1 – Discover IPFS on a virtual machine](https://aws.amazon.com/blogs/database/part-1-ipfs-on-aws-discover-ipfs-on-a-virtual-machine/)
+
+- Did you know you can run IPFS on AWS? In this 3-part series on the AWS Database Blog, you'll learn how to do it thanks to a step-by-step guide. [Check it out!](https://aws.amazon.com/blogs/database/part-1-ipfs-on-aws-discover-ipfs-on-a-virtual-machine/)
+
+[OrbitDB v1.0 releases](https://github.com/orbitdb/orbitdb)
+
+- "OrbitDB is a serverless, distributed, peer-to-peer database. OrbitDB uses IPFS as its data storage and Libp2p Pubsub to automatically sync databases with peers. It's an eventually consistent database that uses Merkle-CRDTs for conflict-free database writes and merges making OrbitDB an excellent choice for p2p and decentralized apps, blockchain applications and local-first web applications." [Learn more here!](https://github.com/orbitdb/orbitdb)
+
+[New in the Ecoystem Directory: dAppling](https://ecosystem.ipfs.tech/project/dappling/)
+
+- Easy way for web3 developers to deploy their frontend to IPFS with a great developer experience. Connect your github and have a deployed site in a few clicks. Automatic CI/CD / Preview Builds / ENS support. [Check it out here!](https://ecosystem.ipfs.tech/project/dappling/)
+
+[New in the Ecosystem Directory: ODD SDK](https://ecosystem.ipfs.tech/project/odd-sdk/)
+
+- ODD SDK is Fission's true local-first, edge computing stack. ODD SDK empowers you to build fully distributed web applications with auth and storage without needing a complex backend. [View it here!](https://ecosystem.ipfs.tech/project/odd-sdk/)
+
+[Popular on the Forums: Questions about a Private IPFS Setup](https://discuss.ipfs.tech/t/how-to-set-up-my-own-bootstrap-nodes-to-enable-discovery-and-connection-between-nodes-with-public-ip-and-nodes-on-a-local-network/16910)
+
+- "How [do I] set up my own bootstrap nodes to enable discovery and connection between nodes with public IP and nodes on a local network?" [Read the discussion.](https://discuss.ipfs.tech/t/how-to-set-up-my-own-bootstrap-nodes-to-enable-discovery-and-connection-between-nodes-with-public-ip-and-nodes-on-a-local-network/16910)
+
+[Job Alert: Filebase is hiring a Senior Digital Marketing Strategist](https://wellfound.com/jobs/2807523-senior-digital-marketing-strategist)
+
+- "Are you a creative and strategic thinker with a passion for driving digital marketing excellence? Do you thrive in dynamic, cutting-edge environments and have a deep understanding of the tech industry? Join us at Filebase, a leading player in the decentralized storage revolution, as a Senior Digital Marketing Strategist." [Learn more here!](https://wellfound.com/jobs/2807523-senior-digital-marketing-strategist)
+
+[LabWeek23 is happening November 13-17](https://23.labweek.io/)
+
+- Have you booked your travel yet? LabWeek23 is happening in Istanbul, Türkiye, from November 13-17, alongside Devconnect! This is your chance to connect and collaborate with visionaries and teams that are domain leaders in ZK Proofs, AI and blockchain, DeSci, decentralized storage, gaming in Web3, public goods funding, cryptoeconomics, and much more. [Learn more about it here!](https://23.labweek.io/)
+
+## **Have something you want featured? 📥**
+
+As part of our ongoing efforts to empower and promote community contributors, we're providing a new way for you to have a chance to influence the monthly IPFS newsletter! If you have something exciting or important that you think the IPFS community should know about, then you can [submit this form](https://airtable.com/appjqlMYucNiOYHl7/shrfPrKe112FW3ucv) to have it be considered for promotion via IPFS communication channels.
+

src/_blog/releasenotes.md

@@ -1,5 +1,19 @@
 ---
 data:
+    - title: 'Just released: Kubo 0.23.0!'
+      date: "2023-10-05"
+      publish_date: null
+      path: https://github.com/ipfs/kubo/releases/tag/v0.23.0
+      tags:
+        - go-ipfs
+        - kubo
+    - title: 'Just released: Kubo 0.22.0!'
+      date: "2023-08-08"
+      publish_date: null
+      path: https://github.com/ipfs/kubo/releases/tag/v0.22.0
+      tags:
+        - go-ipfs
+        - kubo
     - title: 'Just released: Kubo 0.21.0!'
       date: "2023-07-03"
       publish_date: null