Merge branch 'main' into dependabot/github_actions/actions/checkout-4

Update 2023-09-amino-refactoring.md

.github/dependabot.yml

@@ -14,4 +14,8 @@ updates:
     assignees:
       - 'zebateira'
     labels:
-      - 'dependencies'
+      - 'dependencies'            
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"

.github/workflows/calibreapp-image-actions.yml

@@ -14,7 +14,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout Repo
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
 
       - name: Compress Images
         uses: calibreapp/image-actions@main

.github/workflows/scheduled-publishing.yml

@@ -8,7 +8,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout repo
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
       - name: Install dependencies
         run: npm ci
       - name: Check for scheduled posts

.github/workflows/stale.yml

@@ -2,25 +2,12 @@ name: Close and mark stale issue
 
 on:
   schedule:
-  - cron: '0 0 * * *'
+    - cron: '0 0 * * *'
+
+permissions:
+  issues: write
+  pull-requests: write
 
 jobs:
   stale:
-
-    runs-on: ubuntu-latest
-    permissions:
-      issues: write
-      pull-requests: write
-
-    steps:
-    - uses: actions/stale@v3
-      with:
-        repo-token: ${{ secrets.GITHUB_TOKEN }}
-        stale-issue-message: 'Oops, seems like we needed more information for this issue, please comment with more details or this issue will be closed in 7 days.'
-        close-issue-message: 'This issue was closed because it is missing author input.'
-        stale-issue-label: 'kind/stale'
-        any-of-labels: 'need/author-input'
-        exempt-issue-labels: 'need/triage,need/community-input,need/maintainer-input,need/maintainers-input,need/analysis,status/blocked,status/in-progress,status/ready,status/deferred,status/inactive'
-        days-before-issue-stale: 6
-        days-before-issue-close: 7
-        enable-statistics: true
+    uses: pl-strflt/.github/.github/workflows/reusable-stale-issue.yml@v0.3

.github/workflows/sync-staging.yml

@@ -27,7 +27,7 @@ jobs:
 
     steps:
       - name: Checkout repo
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - name: Sync target branch

README.md

@@ -12,46 +12,6 @@ This repository contains code and content for the [IPFS Blog & News](https://blo
 
 **If you just want to submit a link (event, academic paper, tutorial, video or news coverage) to add to the site, [use this easy form](https://airtable.com/shrNH8YWole1xc70I)!**
 
-## For post authors/editors
-
-There are 2 ways to create a new blog post:
-- Via the [Forestry](https://forestry.io) editor
-- Via a [manual pull request](#creating-a-new-blog-post-via-github-pull-request)
-
-### Creating a new blog post using Forestry
-Forestry is a content management system (CMS) that automatically creates and manages Github PRs for each new post. Using Forestry offers you WYSIWYG editing (in addition to raw markdown mode), easy image upload/crop tools, and instant previews. If you're a regular contributor to the IPFS blog and would like to request Forestry access, contact Emily Vaughan.
-
-Forestry uses the `staging` branch as a work-in-progress scratchpad for blog content. Once content in `staging` is approved, it can be merged into `main`, which is the branch that feeds the production site at blog.ipfs.tech. Merges into `main` are _automatically deployed_ to the production site using [Fleek](https://fleek.co/).
-
-### Forestry authoring/editing tips
-
-- Use the "Content Types" section of Forestry's left-hand menu to drill down to the type of item (blog post, video, news coverage, event) you want to create/edit.
-- For card and blog post header images, **be sure to use the [image crop/scale tool](https://blog.ipfs.tech/image-crop/)** to resize and save images so they're the correct dimensions. (Don't have an image? Don't worry, there are generic fallback images.)
-- Want to embed a YouTube video in a blog post? Switch to raw markdown view and use `@[youtube](videoID)`, substituting the video's unique ID from the URL (e.g. `https://www.youtube.com/watch?v=eFbKKsEoQNg`) for `videoID`.
-- To switch between WYSIWYG and raw markdown while writing a blog post, choose "Raw Editor" or "WYSIWYG Editor" from the dots menu at the top right of the page:<br/>![image](https://user-images.githubusercontent.com/1507828/110036257-fbe93e00-7cf9-11eb-935c-a70f9d21c14f.png)
-
-### Forestry build preview tips
-
-While WYSIWYG mode usually gives you a good enough idea of what a blog post will look like, you can also load Forestry's own _build preview_ in a new tab by clicking the eye icon at the top right of the page:<br/>![image](https://user-images.githubusercontent.com/1507828/110036918-f4766480-7cfa-11eb-9cf3-a0082e61a7a0.png)
-
-This build preview lets you preview changes to any content type (not just blog posts), and _does not_ require you to save your changes in order to see them.
-
-A few tips:
-
-- Click the eye icon to _regenerate_ a build preview at any time from a Forestry edit page. You may need to reload the build preview tab if you don't see changes come through immediately.
-- Occasionally, a build preview page gets stuck at a URL ending in `forestry/pending` or simply won't load. In this case, try the following:
-  - Remove `forestry/pending` from the URL and try again.
-  - Check the Previews section of Forestry's [`Site > Settings` page](https://app.forestry.io/sites/lg5t7mxcqbr-da/#/settings/previews) to see the preview server's current status, start/stop/restart the server, or examine the logs for errors. Simply restarting the preview server can fix many problems.
-  - If all else fails, save your changes, wait a few minutes, and take a look at [Fleek's build of the latest version of the `staging` branch](https://ipfs-blog-staging.on.fleek.co/). It's a considerably slower build/deploy time, but does reflect the latest changes once it finishes deploying.
-
-### To deploy to the live site
-
-Changes you _save_ in Forestry are written directly to the `staging` branch and automatically generate a staging preview at https://ipfs-blog-staging.on.fleek.co/.
-
-**Once a staged post is ready to go live, please PR `staging` to `main` using [this handy shortcut](https://github.com/ipfs/ipfs-blog/compare/main...staging?expand=1).** Give your PR a title explaining what changes are inside (the default just says "Staging", which isn't helpful.) _Note that if multiple posts are in-flight in staging and only one is approved to go live, your PR may need some massaging by a reviewer._
-
-_Note for PR reviewers: While we continue to dogfood Forestry, please leave your edits in comments rather than making additional commits._ As our overall workflow continues to solidify, this direction may change.
-
 ### Creating a new blog post via Github pull request
 
 Each blog post is a markdown file in the [`src/_blog`](./src/_blog) folder, with a little metadata at the top (known as YAML frontmatter) to help us create the post index page.
@@ -110,7 +70,7 @@ Each post can have a custom image that is shown on the [blog homepage](https://b
 
 To create a pull request, you will need to fork this repository. See the GitHub docs on [how to create a pull request from a fork](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request-from-a-fork). If you have the [GitHub CLI](https://cli.github.com/) installed, you can use the [`gh pr create` command](https://cli.github.com/manual/gh_pr_create) from the terminal to conveniently create a pull request.
 
-Once you create the pull request, await review.
+Once you create the pull request, await review. If you have permissions to merge, always preview the post first to ensure everything looks right. You can do this by clicking on the "Details" link next to the **fleek/build** check that runs automatically. Clicking this link will take you to a staging site where you will then need to click on the intended post in the feed to see it.
 
 ### To add a URL redirect for a blog post
 
@@ -135,7 +95,7 @@ To build a local copy, run the following:
 1. Move into the `ipfs-blog` folder and install the npm dependencies:
 
    ```bash
-   cd ipfs-docs
+   cd ipfs-blog
    npm install
    ```
 

package.json

@@ -43,7 +43,7 @@
     "postcss": "^7.0.35",
     "prettier": "^2.3.2",
     "slug": "^5.1.0",
-    "standard-version": "^9.5.0",
+    "standard-version": "^9.3.0",
     "stylelint": "^13.13.1",
     "stylelint-config-prettier": "^8.0.2",
     "stylelint-prettier": "^1.2.0",

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-05-multi-gateway-browser-client.md

@@ -2,10 +2,10 @@
 title: IPFS Multi-Gateway Experiment in Chromium
 description: A new approach to implementing ipfs:// and ipns:// support natively in the browser, using a client-only approach and fetching verifiable responses from multiple HTTP gateways.
 author: John Turpish
-date: 2023-05-23
+date: 2023-06-01
 permalink: "/2023-05-multigateway-chromium-client/"
 translationKey: 2023-05-multigateway-chromium-client
-header_image: "/2023-05-multigateway-chromium-client-header.png"
+header_image: "/multi-gateway-experiment.png"
 tags:
 - browsers
 - chromium

src/_blog/2023-07-rust-libp2p-based-ipfs-bootstrap-node.md

@@ -0,0 +1,170 @@
+---
+title: A Rusty Bootstrapper
+description: 'Running rust-libp2p-server on one of our four IPFS bootstrap nodes.'
+author: Max Inden (@mxinden)
+date: 2023-07-24
+permalink: '/2023-rust-libp2p-based-ipfs-bootstrap-node/'
+header_image: ''
+tags:
+  - 'Kademlia'
+  - 'Rust'
+---
+
+# Summary
+
+As of July 13, 2023, one of the four "public good" IPFS bootstrap nodes operated by Protocol Labs has been running [rust-libp2p-server](https://github.com/mxinden/rust-libp2p-server) instead of [Kubo](https://github.com/ipfs/kubo), which uses [go-libp2p](https://github.com/libp2p/go-libp2p/). rust-libp2p-server is a thin wrapper around [rust-libp2p](https://github.com/libp2p/rust-libp2p). We run both Kubo and rust-libp2p-server on IPFS bootstrap nodes to increase resilience. A bug or vulnerability is less likely to be in both Kubo and rust-libp2p-server than Kubo alone. In addition to increasing resilience, we gain experience running large rust-libp2p based deployments on the IPFS network.
+
+![rust-libp2p bootstrap node establishing its first connections](../assets/2023-07-rust-libp2p-based-ipfs-bootstrap-node-connections-established.png)
+
+# IPFS Public DHT Bootstrap Nodes
+
+_What is an IPFS bootstrap node?_
+
+> A Bootstrap Node is a trusted peer on the IPFS network through which an IPFS node learns about other peers on the network. [...]
+
+See [IPFS Glossary](https://docs.ipfs.tech/concepts/glossary/#bootstrap-node).
+
+A new node trying to join the "[public IPFS DHT](https://github.com/ipfs/ipfs/discussions/473)", i.e. trying to bootstrap, will:
+
+1. Connect to its (pre-) configured bootstrap nodes.
+2. Run some variation of the [Kademlia bootstrap process](https://github.com/libp2p/specs/tree/master/kad-dht#bootstrap-process) which boils down to iteratively:
+    1. Generating random IDs.
+    2. Asking already discovered nodes whether they know anyone closer to those IDs.
+
+Thus the only thing that an IPFS bootstrap node needs to do is:
+
+- Allow incoming connections.
+- Maintain a healthy Kademlia routing table.
+- Reply to Kademlia `FIND_NODE` requests based on nodes in its routing table.
+
+Let's dive a bit deeper. In the case of Kubo the [DNSAddr](https://github.com/multiformats/multiaddr/blob/master/protocols/DNSADDR.md) addresses of the IPFS bootstrap nodes are shipped within the release binary.
+
+``` go
+// DefaultBootstrapAddresses are the hardcoded bootstrap addresses
+// for IPFS. they are nodes run by the IPFS team. docs on these later.
+// As with all p2p networks, bootstrap is an important security concern.
+var DefaultBootstrapAddresses = []string{
+	"/dnsaddr/bootstrap.libp2p.io/p2p/QmNnooDu7bfjPFoTZYxMNLWUQJyrVwtbZg5gBMjTezGAJN",
+	"/dnsaddr/bootstrap.libp2p.io/p2p/QmQCU2EcMqAqQPR2i9bChDtGNJchTbq5TbXJJ16u19uLTa",
+	"/dnsaddr/bootstrap.libp2p.io/p2p/QmbLHAnMoJPWSCR5Zhtx6BHJX9KiKNN6tpvbUcqanj75Nb",
+	"/dnsaddr/bootstrap.libp2p.io/p2p/QmcZf59bWwK5XFi76CZX8cbJ4BhTzzA3gU1ZjYZcYW3dwt",
+    // ...
+}
+```
+
+See [`bootstrap_peers.go` on github.com/ipfs/kubo](https://github.com/ipfs/kubo/blob/v0.21.0/config/bootstrap_peers.go#L11C1-L24C2).
+
+One can resolve those `/dnsaddr/...` through iterative DNS queries. Below  is an example for the node with the peer ID `QmbLHAnMoJPWSCR5Zhtx6BHJX9KiKNN6tpvbUcqanj75Nb`. This IPFS bootstrap node is running Kubo.
+
+```
+dig +short -t txt _dnsaddr.bootstrap.libp2p.io
+"dnsaddr=/dnsaddr/am6.bootstrap.libp2p.io/p2p/QmbLHAnMoJPWSCR5Zhtx6BHJX9KiKNN6tpvbUcqanj75Nb"
+[...]
+```
+
+```
+dig +short -t txt _dnsaddr.am6.bootstrap.libp2p.io
+"dnsaddr=/ip6/2604:1380:4602:5c00::3/udp/4001/quic-v1/p2p/QmbLHAnMoJPWSCR5Zhtx6BHJX9KiKNN6tpvbUcqanj75Nb"
+[...]
+```
+
+Finally connecting to the bootrap node shows us the protocols it supports.
+Below example uses [`libp2p-lookup`](https://github.com/mxinden/libp2p-lookup/) but `ipfs swarm connect` followed by `ipfs id` can be used instead.
+
+
+```
+libp2p-lookup direct --address /ip6/2604:1380:4602:5c00::3/udp/4001/quic-v1/p2p/QmbLHAnMoJPWSCR5Zhtx6BHJX9KiKNN6tpvbUcqanj75Nb
+
+Lookup for peer with id PeerId("QmbLHAnMoJPWSCR5Zhtx6BHJX9KiKNN6tpvbUcqanj75Nb") succeeded.
+
+Protocol version: "ipfs/0.1.0"
+Agent version: "kubo/0.20.0/b8c4725"
+Listen addresses:
+        - "/ip6/2604:1380:4602:5c00::3/udp/4001/quic-v1"
+        - [...]
+Protocols:
+        - /ipfs/kad/1.0.0
+        - [...]
+```
+
+Note the `Agent version: "kubo/0.20.0/b8c4725"` and the supported protocols `Protocols: - /ipfs/kad/1.0.0`.
+
+# Motivation
+
+_Why run both Kubo and rust-libp2p2-server bootstrap nodes?_
+
+This choice is influenced by three main areas: the benefit of diverse implementations, the opportunity to test rust-libp2p at large scale, and the presence of Rust in the IPFS network.
+
+Implementation Diversity: Operating both Kubo and rust-libp2p-server bootstrap nodes contributes to the network's overall resilience and security. It's like having a second line of defense; if one system encounters an issue, the other is there to continue functioning. For instance, a recent bug impacted Kubo IPFS bootstrap nodes, closing incoming connections, right after their successful establishment, due to a QUIC version mismatch. By using both Kubo and rust-libp2p-server, we ensure that nodes can still join the network, even if one set of bootstrap nodes is unavailable.
+
+Testing Rust-Libp2p at Large Scale: Our use of rust-libp2p-server also provides a valuable opportunity to examine how it behaves at a larger scale. Software performance can vary depending on scale, and these differences are hard to predict without actual real-world deployments. Now we can gain insights similar to those we acquired from other large deployments such as [Polkadot](github.com/paritytech/polkadot/) and [Ethereum](https://blog.libp2p.io/libp2p-and-ethereum/).
+
+Encouraging Rust in the IPFS Network: Lastly, by operating a rust-libp2p bootstrap node, we hope to motivate other developers to build IPFS-based applications using rust-libp2p. This could lead to an increase in the use of Rust, fostering a more diverse and vibrant ecosystem.
+
+# rust-libp2p(-server) in Action
+
+_What is rust-libp2p(-server) and how does it operate as an IPFS bootstrap node?_
+
+[rust-libp2p](https://github.com/libp2p/rust-libp2p) is an implementation of the libp2p specification in Rust, a popular systems programming language. The rust-libp2p project was [initiated around 2018](https://www.parity.io/blog/why-libp2p) and since then, it has powered network like Ethereum through its Rust implementation [Lighthouse](https://github.com/sigp/lighthouse) and [Polkadot](github.com/paritytech/polkadot/) along with the [Substrate](https://github.com/paritytech/substrate/) ecosystem. You can find more rust-libp2p users [here](https://github.com/libp2p/rust-libp2p#notable-users).
+
+[rust-libp2p-server](https://github.com/mxinden/rust-libp2p-server/) is just thin wrapper around rust-libp2p. It combines rust-libp2p's TCP, QUIC and Kademlia-DHT implementation into a single binary. Looking up the new rust-libp2p-server IPFS bootstrap node `ny5` via [`libp2p-lookup`](https://github.com/mxinden/libp2p-lookup/) confirms just that. Note the `Agent version: "rust-libp2p-server/0.12.0"`. and `Protocols: - /ipfs/kad/1.0.0`.
+
+
+```
+libp2p-lookup direct --address /dnsaddr/ny5.bootstrap.libp2p.io
+
+Lookup for peer with id PeerId("QmQCU2EcMqAqQPR2i9bChDtGNJchTbq5TbXJJ16u19uLTa") succeeded.
+
+Protocol version: "ipfs/0.1.0"
+Agent version: "rust-libp2p-server/0.12.0"
+Listen addresses:
+        - [...]
+Protocols:
+        - /ipfs/kad/1.0.0
+        - [...]
+```
+
+## Some Numbers
+
+On the new bootstrap node we see around 15 new inbound connections per second. The majority of these connections are established via QUIC (see `ip4/udp/quic`).
+
+![rust-libp2p bootstrap node establishing its first connections](../assets/2023-07-rust-libp2p-based-ipfs-bootstrap-node-new-incoming-connections.png)
+
+The node is handling > 30k connections concurrently, thus being connected to roughly [15% of nodes of the public IPFS DHT](https://probelab.io/ipfsdht/#client-vs-server-node-estimate).
+
+![rust-libp2p bootstrap node establishing its first connections](../assets/2023-07-rust-libp2p-based-ipfs-bootstrap-node-connections-established.png)
+
+Across these connections the node handles around 40 Kademlia requests per second, most of which are Kademlia `FIND_NODE` requests.
+
+![rust-libp2p bootstrap node establishing its first connections](../assets/2023-07-rust-libp2p-based-ipfs-bootstrap-node-new-incoming-kademlia-requests.png)
+
+The number of connections does not have a significant impact on CPU usage of the underlying machine.
+
+![rust-libp2p bootstrap node establishing its first connections](../assets/2023-07-rust-libp2p-based-ipfs-bootstrap-node-cpu.png)
+
+The node uses `< 300 kbyte` of memory per connection.
+
+![rust-libp2p bootstrap node establishing its first connections](../assets/2023-07-rust-libp2p-based-ipfs-bootstrap-node-memory.png)
+
+A small tangent: in case you are interested in more IPFS public DHT metrics, take a look at the [probelab DHT metrics and reports](https://probelab.io/ipfsdht/).
+
+# Closing
+
+If you want to learn more:
+
+- Read up on the [libp2p project](https://libp2p.io/)
+- Explore the [rust-libp2p implementation](https://github.com/libp2p/rust-libp2p)
+- See the thin rust-libp2p wrapper at [mxinden/rust-libp2p-server](https://github.com/mxinden/rust-libp2p-server/)
+- And lastly, the [public IPFS DHT measurements](https://probelab.io/ipfsdht/) are always a good read
+
+A lot of this work was done by [@mcamou](https://github.com/mcamou) from the [Protocol Labs EngRes Bifrost team](https://pl-strflt.notion.site/Bifrost-2423fee6b15243158e85e35d8e22241d?pvs=4). Mario has handled the deployment and the team is operating the bootstrap nodes as a whole. Thanks, [@mcamou](https://github.com/mcamou) and team!
+
+FAQ:
+
+- Do I have to use the default bootstrap nodes?
+
+  No, you don't have to use `/dnsaddr/bootstrap.libp2p.io`. You can remove Protocol Labs' default nodes and add your own or use both for better reliability.
+
+- Do we plan to run rust-libp2p-server on all IPFS bootstrap nodes?
+
+  No.

src/_blog/2023-08-an-observatory-for-the-ipfs-network.md

@@ -0,0 +1,92 @@
+---
+title: An Observatory for the IPFS Network
+description: 'The ProbeLab team has built a resilient and fully-automated infrastructure to monitor the performance of core IPFS protocols!'
+author: Yiannis Psaras (@yiannisbot)
+date: 2023-08-03
+permalink: '/2023-ipfs-observatory/'
+header_image: '/blog-post-probelabio.png'
+tags:
+  - measurements
+  - DHT
+  - IPNI
+---
+
+# tl;dr
+
+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. All of what we have so far lives at [https://probelab.io](https://probelab.io) with results being auto-updated on a daily basis.
+
+
+## Why measurement work is important
+
+Measuring operational networked systems is the cornerstone of system reliability, stability, and great user experience. Unless someone measures the performance of their system, it is very difficult to spot problems and inconsistencies between protocol design and actual operation. Most importantly, it is very difficult to be able to direct engineering effort to the right direction in order to solve actual problems, deal with bottlenecks, and eventually improve performance.
+
+System and network measurements are normally straightforward when there is a single (or a few) points of control. The task becomes significantly more challenging in the case of open-source, decentralized, and permissionless systems such as IPFS where there is no single point of control (or any gatekeeping entity).
+
+## ProbeLab
+
+This is where our team’s efforts come into the picture. ProbeLab is focusing on protocol measurement, benchmarking, and optimization for Web3.0 protocols in general and IPFS in particular. During the past year we strived to build all the necessary tooling and backend infrastructure in order to be able to reliably measure the most critical aspects of the decentralized network. To avoid this being our own knowledge and instead share our findings with the community, we’ve also built a public-facing front-end where our key results are being reported on a daily basis: [https://probelab.io](https://probelab.io) 
+
+One key thing that makes [https://probelab.io](https://probelab.io) different to a dashboard is that there is detailed explanation of the measurement methodology and the measurement setup, so that viewers can understand whether the results they’re observing fit their own setup and use-case. Ultimately, [https://probelab.io](https://probelab.io) should become the point of reference for engineers, as well as executives that are running (or are considering running) their applications on top of the IPFS network.
+
+## Our focus (so far)
+
+Apart from [several](https://www.notion.so/pl-strflt/Optimistic-Provide-07ce632c6de54aec953ec0e9ca2bbcf5?pvs=4) [protocol](https://github.com/plprobelab/network-measurements/blob/master/results/rfm16-bitswap-discovery-effectiveness.md) [optimization](https://github.com/plprobelab/network-measurements/blob/master/results/rfm15-nat-hole-punching.md) projects that ProbeLab has taken up so far, our primary focus on the measurements front has been the main component that supports decentralized content routing in the IPFS protocol stack, that is, the IPFS Public DHT network. Our focus has not been a random pick, but instead a thoughtful consideration given that this is where performance has been mostly unknown and mostly unpredictable - until now!
+
+That said, we have extended our efforts to other critical parts of the architecture, such as the [InterPlanetary Network Indexers](https://docs.ipfs.tech/concepts/ipni/), and we plan to add more components to our monitoring infra in the near future.
+
+Sample projects where our measurement infrastructure has helped the ecosystem tremendously are:
+
+- **The Hydra Dial Down:** [Hydra Boosters](https://github.com/libp2p/hydra-booster) are a special type of DHT server node designed to accelerate content routing performance in the IPFS network. They were introduced in 2019 and were intended as an interim solution while exploring other DHT scalability techniques. The IPFS DHT network and its supporting protocols have advanced significantly since then, and the (not insignificant) cost of operating Hydras was put in question by our team. We have found that Hydras improve content routing performance by not more than 10-15% on average, which was considered minor, compared to its operational cost. The team carried out a progressive dial down of Hydras after communicating our intentions with the community (see [details](https://discuss.ipfs.tech/t/dht-hydra-peers-dialling-down-non-bridging-functionality-on-2022-12-01/15567)) and confirmed our performance estimates of a Hydra-less network. You can find an explanatory talk of our measurement estimates at IPFS Camp 2022 [here](https://www.youtube.com/watch?v=zhzxJGoLTg0) and the full project report [here](https://github.com/protocol/network-measurements/blob/master/results/rfm21-hydras-performance-contribution.md).
+
+- **Unresponsive Nodes Incident:** ProbeLab’s measurement work and tooling has proven critical for incidents that nearly brought the IPFS network to its knees. Around January 2023, a software misconfiguration resulted in more than 50% of IPFS DHT network nodes becoming unresponsive. Through rigorous measurement and analysis of the measurement results, the engineering teams have chosen the right next steps to resolve the situation in record time, something that would have been significantly more difficult without the numbers that the ProbeLab team has provided. You can read all of the details regarding the incident, the response, and the measurements that our team carried out in [this previous blog post](https://blog.ipfs.tech/2023-ipfs-unresponsive-nodes/).
+
+## ProbeLab Tooling
+
+Our primary tooling is open-source and linked from the same website under: [https://probelab.io/tools/](https://probelab.io/tools/). There are detailed “how to” guides for each tool so that community members can get familiar and start using them for their own studies. The tools we have used so far include:
+
+- [`Nebula`](https://probelab.io/tools/nebula/): a libp2p DHT crawler and monitor that is designed to track the liveliness and availability of peers.
+- [`Parsec`](https://github.com/plprobelab/parsec): a DHT and IPNI performance measurement tool that is used to gather accurate data on the performance of DHT and IPNI lookups and publications.
+- [`Tiros`](https://github.com/plprobelab/tiros): a retrieval and rendering metrics measurement tool of websites loaded over IPFS. It is designed to help developers monitor and optimize the performance of their IPFS-hosted websites. It also measures and compares the IPFS metrics with their HTTPS counterparts.
+
+## What we know now that we didn’t know before
+
+The plots and experiments at [https://probelab.io](https://probelab.io) offer visibility into lots of aspects that were not visible at all beforehand, or at least were not widely available. Our monitoring and observation of IPFS’s primary content routing components’ performance over the last couple of quarters reveals that at the time of writing:
+
+- More than 25k DHT Server peers stay online for more than 80% of the time of a given week [[link to plot](https://probelab.io/ipfskpi/#dht-availability-classified-overall-plot)]
+
+![dht-availability-classified-overall.png](../assets/2023-08-ipfs-observatory-dht-availability-classified-overall.png)
+
+- Despite the above fact, the churn rate in the network is rather high with 80% of DHT Server peers leaving the network in 3hrs or less after they appeared online [[link to plot](https://probelab.io/ipfsdht/#dht-peers-churn-cdf-overall-plot)]
+
+![dht-peers-churn-cdf-overall (1).png](../assets/2023-08-ipfs-observatory-dht-peers-churn-cdf-overall.png)
+
+- The Median DHT Lookup Performance (i.e., the time to first provider record) is at 600ms as measured from 7 different geographical regions. It is worth highlighting that the lookup performance from the EU and North America, where most DHT nodes reside, is significantly better than other regions and stands at 200-250ms [[link to plot](https://probelab.io/ipfsdht/#dht-lookup-performance-cdf-region-plot)].
+
+![dht-lookup-performance-cdf-region.png](../assets/2023-08-ipfs-observatory-dht-lookup-performance-cdf-region.png)
+
+- Websites hosted on IPFS are served faster over kubo than HTTP for those well-performing regions (EU and North America) [[link to plot](https://probelab.io/websites/#websites-http-comparison-ttfb-p90)].
+
+![websites-http-comparison-ttfb-p90.png](../assets/2023-08-ipfs-observatory-websites-http-comparison-ttfb-p90.png)
+
+- The [cid.contact](http://cid.contact) IPNI maintains a stable lookup performance below the 300ms mark at the P90 for uncached content and across all 7 regions [[link to plot](https://probelab.io/ipni/cid.contact/#ipni-snapshot-uncached-latencies-cdf-cidcontact-plot)].
+
+![ipni-snapshot-uncached-latencies-cdf-cidcontact.png](../assets/2023-08-ipfs-observatory-ipni-snapshot-uncached-latencies-cdf-cidcontact.png)
+
+## Where to find more
+
+Head over to [https://probelab.io](https://probelab.io) to dive into all the results and explanation of the experiments.
+
+It is worth noting that we do not provide commentary on the results presented on the website itself. Instead, discussion around results reported at [https://probelab.io](https://probelab.io) is taking place at the [IPFS Discussion Forum](https://discuss.ipfs.tech/c/testing-and-experiments/measurements/39).
+
+You can reach out to the ProbeLab team (e.g., if you’re interested contributing to the measurement effort, or have a request) through:
+
+- the `#probe-lab` channel in IPFS Discord [[invite link](https://discord.gg/ipfs)], or Filecoin Slack [[invite link](https://filecoin.io/slack)] (bridged channel).
+- The team’s email: [probelab@protocol.ai](mailto:probelab@protocol.ai)
+
+We also hold bi-weekly Office Hours, where we invite the community and our collaborators to join and bring up questions, challenges they face and topics for discussion. You can sign up through [this lu.ma page](https://lu.ma/ipfs-network-measurements).
+
+<!-- ## A guide for website owners hosting with IPFS
+
+Last, but not least, we have developed an in-depth methodology to monitor performance of websites hosted on IPFS. We are currently monitoring most of PL’s websites and provide a breakdown of web access performance metrics (primarily using [Web Vitals](https://web.dev/vitals/)). This is very helpful for monitoring overall performance, but especially for debugging in case of poor performance, or errors while fetching website content.
+
+++ linking to the howto guide as well as how to use it, if we finalise and decide to include. -->

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/2023-ipfs-thing-recap-content-routing.md

@@ -89,6 +89,4 @@ The talk was followed by a discussion on a set of open questions as we scale the
 
 It's great to see the IPFS community coming together and celebrating the latest advancements in the field. A big thank you to all who attended the track at Brussels and to the speakers who presented and helped generate questions. Last but not least, a massive shout-out to the community that tirelessly drives the vision (a better web for all) forward. 🙇
 
-And there's more to look forward to! The dates for [IPFS Camp 2023](https://lu.ma/ipfscamp23-prereg) in Bangalore, India have already been announced for early November. It's never too early to start preparing your talks and presentations. 😊
-
 See you on the decentralised web! ✊

src/_blog/2023-thing-web-track.md

@@ -114,9 +114,7 @@ The Browsers, Platforms and Standards team wants to share our thoughts early and
 
 Thanks to all the speakers for the day and also to the rad people who joined and asked great questions.
 
-IPFS Camp is already in planning for early November... in BANGALORE INDIA! So block your calendars and start thinking about the web you want to see exist, so you can submit a talk there. 😄
-
-Until then, come hang out in our superbridged megachannel:
+Until our next event, come hang out in our superbridged megachannel:
 
 * #browsers-and-platforms on Filecoin Slack ([join](https://filecoin.io/slack))
 * #browsers-and-standards on Element/Matrix ([join](https://matrix.to/#/#browsers-and-standards:ipfs.io))

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-newsletter-194.md

@@ -0,0 +1,87 @@
+---
+title: Welcome to IPFS News 194!
+description: Featuring Durin, Helia advancements, recaps of IPFS Thing 2023 from individual track leads, and much more!
+author: ''
+date: 2023-06-06
+permalink: "/newsletter-194"
+translationKey: ''
+header_image: "/ipfsnews.png"
+tags:
+- newsletter
+---
+
+The month of May was packed full of new blog posts, þing 2023 recaps, and exciting milestones in the continued growth of IPFS. This edition of the newsletter covers everything from the launch of a new mobile app called Durin to a blog post explaining how to host dynamic content on IPFS using Helia.
+
+Let’s dive in…
+
+## **Brand New on IPFS ✨**
+
+[Announcing Durin: a New Mobile App for the IPFS Network](https://blog.ipfs.tech/announcing-durin/)
+
+- Durin is a new experimental app designed to make IPFS more accessible on mobile devices. Whereas in the past interacting with IPFS on mobile was difficult, you can now read and share to IPFS from iPhones and Android devices. [Learn more and download here!](https://blog.ipfs.tech/announcing-durin/)
+
+[How to Host Dynamic Content on IPFS](https://blog.ipfs.tech/2023-how-to-host-dynamic-content-on-ipfs/)
+
+- The new JS implementation of IPFS called Helia is finally here and you can do lots of things with it (like connect to the DHT)! In a recent blog post, [@tabcat00](https://twitter.com/tabcat00) presented a way to host dynamic content on IPFS that utilizes Helia. [Check it out!](https://blog.ipfs.tech/2023-how-to-host-dynamic-content-on-ipfs/)
+
+[IPFS Multi-Gateway Experiment in Chromium](https://blog.ipfs.tech/2023-05-multigateway-chromium-client/)
+
+- John Turpish of Little Bear Labs goes over a new approach to implementing ipfs:// and ipns:// support natively in the browser, using a client-only approach and fetching verifiable responses from multiple HTTP gateways. [Dive in here](https://blog.ipfs.tech/2023-05-multigateway-chromium-client/)!
+
+[js-IPFS deprecation / replaced by Helia](https://blog.ipfs.tech/202305-js-ipfs-deprecation-for-helia/)
+
+- js-IPFS is in the process of being deprecated so you should port your apps to Helia to receive bug fixes, features, and performance improvements moving forwards. [Read more on the IPFS blog](https://blog.ipfs.tech/202305-js-ipfs-deprecation-for-helia/)!
+
+[IPFS Network Measurement Reports](https://github.com/protocol/network-measurements/tree/master/reports/2023)
+
+- If you're interested in IPFS Network performance metrics and network cartography, make sure to check out ProbeLab's Weekly reports! The reports are posted every Monday at the [network-measurements repository on Github](https://github.com/protocol/network-measurements/tree/master/reports/2023) with commentary and discussion happening on [the IPFS Discussion Forum](https://discuss.ipfs.tech/c/testing-and-experiments/35). Make sure to get involved in the discussion and reach out through the discussion forum, the network-measurements repository (by opening an issue), or at the #probe-lab channel in the IPFS Discord, or FIL slack.
+
+[What happens when half the network is down?](https://blog.ipfs.tech/2023-ipfs-unresponsive-nodes/)
+
+- In 90% of networks, or networked systems, this is a grand-scale disaster... but for IPFS it's a very different story. Find out what happens in [a recent incident report published on the blog](https://blog.ipfs.tech/2023-ipfs-unresponsive-nodes/)!
+
+[Introducing Rusty Lassie, a Rust wrapper for Lassie](https://crates.io/crates/lassie)
+
+- A thin library embedding Lassie via CGo and FFI. With Rusty-Lassie, you can easily embed Lassie in your Rust project, start a Lassie HTTP server in a background thread, and retrieve CAR content using any HTTP client. [Learn more about the project here](https://crates.io/crates/lassie)!
+
+## **IPFS Thing Track Recaps 📝**
+
+[Recap: Content Routing (þing 2023)](https://blog.ipfs.tech/2023-ipfs-thing-content-routing-track/)
+
+[Recap: Community & Governance (þing 2023)](https://blog.ipfs.tech/2023-ipfs-community-governance/)
+
+[Recap: HTTP Gateways (þing 2023)](https://blog.ipfs.tech/2023-http-gateways-recap/)
+
+[Recap: IPFS on the Web (þing 2023)](https://blog.ipfs.tech/2023-ipfs-thing-web-track/)
+
+[libp2p at IPFS þing 2023 Recap](https://blog.libp2p.io/2023-libp2p-IPFS-Thing-recap/)
+
+## **Around the Ecosystem 🌎**
+
+[Founders Series, Episode 11: Juan Benet of Protocol Labs [Video]](https://www.youtube.com/watch?v=r-nU_MI2lV4)
+
+- In this talk from LabWeek22 last November in Lisbon, Juan explains the importance of R&D, the lack of funding it receives, and how he hopes to solve this problem with the Protocol Labs Network, an ecosystem of teams based on open source, working together bridge what he calls the innovation chasm — the separation between research and deployment of product. [Watch it on YouTube!](https://www.youtube.com/watch?v=r-nU_MI2lV4)
+
+[Filecoin & IPFS Ecosystem Roundup [Video]](https://youtu.be/kXnSklUL5NE)
+
+- In this revamped monthly public video we give builders and community members a platform to share how they’re making web3 work better for all of us. Please [fill out this form](https://airtable.com/shrcadO9WAnQ5nJvA) to nominate a Team/Project to be featured as a 'Win of the Month'! Join us live the first Thursday of every month, and [watch the May round up now!](https://www.youtube.com/watch?v=kXnSklUL5NE)
+
+[IPNS on Lighthouse](https://twitter.com/nanditmehra/status/1664317411313733634?s=20)
+
+- IPNS support is now live on Lighthouse. Now build creative dapps with the world's best p2p tech for mutable data. Edit and upload your data and build dynamic NFT collections, mutable file systems, and much more with this IPNS support. [See the announcement on Twitter!](https://twitter.com/nanditmehra/status/1664317411313733634?s=20)
+
+[IPFS Open Metaverse Base Camp Accelerator](https://twitter.com/OVioHQ/status/1662062713550299136?s=20)
+
+- We're thrilled to announce the teams making up the latest IPFS Open Metaverse Base Camp accelerator cohort. This 12-week program will accelerate teams leveraging IPFS, Filecoin & [@fvmdev](https://twitter.com/fvmdev), paving the way forwards in the open data economy. [Read all about in this Twitter thead!](https://twitter.com/OVioHQ/status/1662062713550299136?s=20)
+
+[Filebase for Startups](https://filebase.com/startups/)
+
+- Filebase now has a program that offers complimentary IPFS storage and dedicated gateways for startups to scale with. You can learn more about it [on their website](https://filebase.com/startups/).
+
+[Protocol Labs Launch Pad](https://protocol.ai/blog/launchpad-summit-paris-2023/)
+
+- Launchpad is a blend of two key components: a dynamic four-week virtual learning cohort, where residents actively participate in remote learning seminars, and an unforgettable one-week in-person “colo” Summit. [Learn more on the Protocol Labs blog](https://protocol.ai/blog/launchpad-summit-paris-2023/)!
+
+[HackFS kicked off on June 2](https://ethglobal.com/events/hackfs2023)
+
+- Late last week, EthGlobal and Protocol Labs kicked off HackFS 2023 with an incredible summit featuring fireside chats on FVM, presentations on the Protocol Labs builders funnel, and even a talk from a surprise guest. [Check out the event's website to catchup](https://ethglobal.com/events/hackfs2023)!

src/_blog/newsletter-195.md

@@ -0,0 +1,96 @@
+---
+title: Welcome to IPFS News 195!
+description: Featuring a deep-dive into the challenges of measuring decentralized networks + more!
+author: ''
+date: 2023-07-06
+permalink: "/newsletter-195"
+translationKey: ''
+header_image: "/ipfsnews.png"
+tags:
+- newsletter
+---
+
+As we enter into the summer months, things are slowing down just a bit as people go on holiday or get some much needed R&R, but that doesn’t mean we don’t have plenty of things to share with you! From a deep-dive into [the challenges of measuring decentralized networks](https://pulse.internetsociety.org/blog/the-challenges-of-measuring-decentralized-networks-the-case-of-the-interplanetary-file-system) to news about Fission adding redirect support of IPFS, this month’s newsletter will keep you in the loop whether this edition finds you in the office, at home, or on the beach. 🏖️
+
+Let’s jump in!
+
+## **Brand New on IPFS ✨**
+
+[Kubo 0.21.0](https://github.com/ipfs/kubo/releases/tag/v0.21.0)
+
+- Saving previously seen nodes for later bootstrapping
+- Gateway: `DeserializedResponses` config flag
+- `client/rpc` migration of `go-ipfs-http-client`
+- Gateway: DAG-CBOR/-JSON previews and improved error pages
+- Gateway: subdomain redirects are now `text/html`
+- Gateway: support for partial CAR export parameters (IPIP-402)
+- `ipfs dag stat` deduping statistics
+- Accelerated DHT Client is no longer experimental
+
+[The Challenges of Measuring Decentralized Networks: The Case of the InterPlanetary File System](https://pulse.internetsociety.org/blog/the-challenges-of-measuring-decentralized-networks-the-case-of-the-interplanetary-file-system)
+
+- In this new blog post from the Internet Society's (ISOC) Pulse project, Yiannis Psaras of ProbeLab shares their experience measuring the stability, performance, and cartography of InterPlanetary File System (IPFS), one of the largest decentralized, P2P networks in operation. [Read it here!](https://pulse.internetsociety.org/blog/the-challenges-of-measuring-decentralized-networks-the-case-of-the-interplanetary-file-system)
+
+[June Protocol Labs EngRes All Hands [Video]](https://www.youtube.com/watch?v=7fbhniQJjDw)
+
+- The PL Engineering and Research (EngRes) Workgroup is formed by teams of core protocol developers, network researchers, and experienced contributors in the Protocol Labs Network. The PL EngRes WG mission is to scale and unlock new opportunities for IPFS, Filecoin, libp2p + IPLD, drive breakthroughs in protocol utility & capability, and scale network-native research & development across the PL Network. The PL EngRes WG hosts monthly all hands meetings to check in on progress, and showcase the growth and new capabilities being unlocked by these research & development teams. [Watch it here!](https://www.youtube.com/watch?v=7fbhniQJjDw)
+
+[js-IPFS Deprecation Reminder: Move to Helia!](https://blog.ipfs.tech/202305-js-ipfs-deprecation-for-helia/)
+
+- **js-IPFS is in the process of being deprecated** so you should port your apps to Helia to receive bug fixes, features, and performance improvements moving forwards. [Read more about it here!](https://blog.ipfs.tech/202305-js-ipfs-deprecation-for-helia/)
+
+## **Around the Ecosystem 🌎**
+
+[Fission adds redirect support for IPFS](https://fission.codes/blog/introducing-redirect-support-for-ipfs/)
+
+- Fission is dedicated to building and improving on decentralized web protocols. Redirect support is an officially accepted improvement for IPFS that makes it easier to host modern web applications. [Learn more about it here!](https://fission.codes/blog/introducing-redirect-support-for-ipfs/)
+
+[IPFS data integrated directly into a blockchain explorer](https://twitter.com/al_koii/status/1665817302279880706?s=20)
+
+- Koii's distributed computing platform uses [web3.storage](https://t.co/KyqdyMsAQy) as a convenient integration for IPFS. Thanks to the lightning-fast w3link gateway and easy to use SDK, developers building on Koii have an extra edge as they implement P2P apps, distributed AI, and more. [Check it out in this Twitter thread!](https://twitter.com/al_koii/status/1665817302279880706?s=20)
+
+[Elevate by Outlier Ventures](https://outlierventures.io/elevate/)
+
+- Elevate is a virtual event series focused on spotlighting Outlier Ventures’ Base Camp Teams. Featuring talks from the very people driving Web3 forward, ELEVATE gives their partners, mentors, program experts and founders themselves an opportunity to showcase the progress they’ve made through their 12-week program. At the virtual event on July 6 (today!) you’ll be able to meet the builders onboarding the next billion users into the Open Metaverse, using IPFS. [Join the event here!](https://outlierventures.io/elevate/)
+
+[ProbeLab Office Hours: IPFS Network Measurements](https://lu.ma/ipfs-network-measurements)
+
+- These open office hours are for anyone interested in network measurements in the IPFS network. The session is hosted by the [ProbeLab](https://blog.ipfs.io/2022-06-15-probelab/) team. During this session, they will discuss issues related to ongoing projects and IPFS network measurement topics more generally with the community. If you're working or are interested in contributing, [make sure to join!](https://lu.ma/ipfs-network-measurements)
+
+[IPFS Multi-Gateway Experiment in Chromium](https://blog.ipfs.tech/2023-05-multigateway-chromium-client/?utm_content=253765483&utm_medium=social&utm_source=twitter&hss_channel=tw-3030006159)
+
+- Learn about a new approach to implementing ipfs:// and ipns:// support natively in the browser, using a client-only approach and fetching verifiable responses from multiple HTTP gateways. [Check out the blog post!](https://blog.ipfs.tech/2023-05-multigateway-chromium-client/?utm_content=253765483&utm_medium=social&utm_source=twitter&hss_channel=tw-3030006159)
+
+[Secure Curves in the Web Cryptography API](https://blogs.igalia.com/jfernandez/2023/06/20/secure-curves-in-the-web-cryptography-api/)
+
+- A new blog post about the collaboration between [@igalia](https://twitter.com/igalia) and [@protocollabs](https://twitter.com/protocollabs) on the implementation of secure curves based on Curve25519 for the Web Cryptography specification. [Read it now!](https://blogs.igalia.com/jfernandez/2023/06/20/secure-curves-in-the-web-cryptography-api/)
+
+[Where to find the Filecoin Community at EthCC](https://fil-paris.io/)
+
+- Looking for the Filecoin community during EthCC? Check out [Filecoin Unleashed](https://filecoinunleashed.io) and [Fil Paris](https://fil-paris.io).
+
+[Accelerate your Web3 journey: Protocol Labs Launchpad Summit on July 16-21](https://protocol.ai/blog/launchpad-summit-paris-2023/)
+
+- Launchpad is a blend of two key components: a dynamic four-week virtual learning cohort, where residents actively participate in remote learning seminars, and an unforgettable one-week in-person “colo” Summit. **[Learn more on the Protocol Labs blog](https://protocol.ai/blog/launchpad-summit-paris-2023/)**
+
+## HackFS Winners 🏅
+
+This year’s [HackFS hackathon](https://ethglobal.com/events/hackfs2023) has come to a close, and several projects were selected as winners for the IPFS category. If you missed it, [learn more about HackFS here](https://ethglobal.com/events/hackfs2023).
+
+Introducing the HackFS 2023 winners for IPFS…
+
+[Web3Stash](https://ethglobal.com/showcase/web3stash-mn6iu) by [@mbcse50](https://twitter.com/mbcse50)
+
+- Web3Stash is a standard library to get a single API to connect to multiple decentralized storage service providers. [Check it out here!](https://ethglobal.com/showcase/web3stash-mn6iu)
+
+[unid.store](https://t.co/xbh9zYbjm9) by [@_Difint_](https://twitter.com/_Difint_)and [@mr13tech](https://twitter.com/mr13tech)
+
+- Super simple file sharing - decentralized, quick, and without registration. [Take a look here!](https://ethglobal.com/showcase/unid-store-2yukr)
+
+[Fileblox](https://ethglobal.com/showcase/fileblox-y0rjm) by [@Lycaoncreatives](https://twitter.com/LycaonCreatives), [@raldblox](https://twitter.com/raldblox), and [@luckscientist](https://twitter.com/luckscientist)
+
+- FileBlox enables the creation of encrypted NFTs. It solves the right-click-and-save problem for our content creators while letting them get all the benefits of tokenization. [Learn more here!](https://ethglobal.com/showcase/fileblox-y0rjm)
+
+[Star Streamer](https://ethglobal.com/showcase/star-streamer-huakw) by [@msakiart](https://twitter.com/msakiart)
+
+- P2P video streaming service for decentralized content sharing with libp2p, ipfs and hypercore. [Check it out here!](https://ethglobal.com/showcase/star-streamer-huakw)

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/releasenotes.md

@@ -1,5 +1,19 @@
 ---
 data:
+    - 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
+      path: https://github.com/ipfs/kubo/releases/tag/v0.21.0
+      tags:
+        - go-ipfs
+        - kubo
     - title: 'Just released: Kubo 0.20.0!'
       date: "2023-05-09"
       publish_date: null