diff --git a/Makefile b/Makefile
index 7bb9322e..1b74cc6b 100644
--- a/Makefile
+++ b/Makefile
@@ -1,5 +1,5 @@
SHELL=/bin/bash
-DOMAIN="ipfs.io"
+DOMAIN="docs.filecoin.io"
IPFSLOCAL="http://localhost:8080/ipfs/"
IPFSGATEWAY="https://ipfs.io/ipfs/"
@@ -21,7 +21,7 @@ endif
HUGO_LOCAL=./bin/hugo
# Path to Hugo binary to use when building the site
HUGO_BINARY=$(HUGO_LOCAL)
-HUGO_VERSION=0.45.1
+HUGO_VERSION=0.54.0
PLATFORM:=$(shell uname)
ifeq ('$(PLATFORM)', 'Darwin')
PLATFORM=macOS
@@ -35,57 +35,21 @@ endif
HUGO_URL="https://github.com/gohugoio/hugo/releases/download/v$(HUGO_VERSION)/hugo_$(HUGO_VERSION)_$(PLATFORM)-$(MACH).tar.gz"
-node_modules:
- $(PREPEND)$(NPM) install $(APPEND)
-
-ipfs-theme:
- $(PREPEND)[ -d build/assets/fonts ] || mkdir -p build/assets/fonts
- $(PREPEND)cp ./node_modules/ipfs-css/fonts/Montserrat* ./build/assets/fonts/ $(APPEND)
- $(PREPEND)cp ./node_modules/ipfs-css/fonts/Inter-UI* ./build/assets/fonts/ $(APPEND)
- $(PREPEND)node scripts/ipfs-css-constants.js $(APPEND)
-
-packages:
- # The JS packages don't actually generate useful docs right now, so skip them
- # $(PREPEND)scripts/pkg2md.sh github.com/ipfs/js-ipfs-api master $(PKGDIR) pkg
- # $(PREPEND)scripts/pkg2md.sh github.com/ipfs/js-ipfs master $(PKGDIR) pkg
- #$(PREPEND)scripts/pkg2md.sh github.com/ipfs/go-ipfs-api v1.2.1 $(PKGDIR) go/pkg
- #$(PREPEND)scripts/pkg2md.sh github.com/ipfs/go-ipfs/core/coreapi v0.4.15 $(PKGDIR) go/pkg
- #$(PREPEND)scripts/pkg2md.sh github.com/ipfs/go-ipfs/core/coreapi/interface v0.4.15 $(PKGDIR) go/pkg
- #$(PREPEND)scripts/pkg2md.sh github.com/ipfs/go-ipfs/core/coreapi/interface/options v0.4.15 $(PKGDIR) go/pkg
-
bin/hugo:
@echo "Installing Hugo to $(HUGO_LOCAL)..."
$(PREPEND)mkdir -p tmp_hugo $(APPEND)
$(PREPEND)curl --location "$(HUGO_URL)" | tar -xzf - -C tmp_hugo && chmod +x tmp_hugo/hugo && mv tmp_hugo/hugo $(HUGO_LOCAL) $(APPEND)
$(PREPEND)rm -rf tmp_hugo $(APPEND)
-resources: ipfs-theme packages
-
-install: bin/hugo node_modules resources
-
-css:
- # Dual calls to less because there seems to be a bug with multiple plugins in v3 :(
- # https://github.com/less/less.js/issues/3187
- $(PREPEND)$(NPMBIN)/lessc -clean-css --autoprefix src/styles/main.less build/assets/main.css $(APPEND)
-
-js:
- $(PREPEND)$(NPMBIN)/browserify src/js/main.js -o build/assets/main.js --debug $(APPEND)
-
-minify-js: js
- $(PREPEND)$(NPMBIN)/uglifyjs --compress --output build/assets/main.js -- build/assets/main.js $(APPEND)
-
-lint:
- $(NPMBIN)/standard src/js/**/*.js
+install: bin/hugo
-build: clean install lint css js minify-js
+build: clean install
$(PREPEND)$(HUGO_BINARY) && \
echo "" && \
echo "Site built out to ./$(OUTPUTDIR)"
-dev: css
+dev: bin/hugo
$(PREPEND)( \
- $(NPMBIN)/nodemon --watch src/styles --ext less,css --exec "$(NPMBIN)/lessc -clean-css --autoprefix src/styles/main.less build/assets/main.css" & \
- $(NPMBIN)/watchify src/js/main.js -o build/assets/main.js --debug & \
$(HUGO_BINARY) server -w --port $(PORT) --bind 0.0.0.0 \
)
@@ -108,4 +72,4 @@ clean:
$(PREPEND)[ ! -d $(PKGDIR) ] || rm -rf $(PKGDIR)/*/
$(PREPEND)[ ! -d build/assets ] || rm -rf build/assets/*
-.PHONY: packages build help deploy publish-to-domain clean
+.PHONY: build help deploy publish-to-domain clean
diff --git a/archetypes/default.md b/archetypes/default.md
new file mode 100644
index 00000000..00e77bd7
--- /dev/null
+++ b/archetypes/default.md
@@ -0,0 +1,6 @@
+---
+title: "{{ replace .Name "-" " " | title }}"
+date: {{ .Date }}
+draft: true
+---
+
diff --git a/bin/.gitkeep b/bin/.gitkeep
deleted file mode 100644
index e69de29b..00000000
diff --git a/ci/Jenkinsfile b/ci/Jenkinsfile
deleted file mode 100644
index 5fafee69..00000000
--- a/ci/Jenkinsfile
+++ /dev/null
@@ -1,4 +0,0 @@
-website([
- website: 'docs.libp2p.io',
- record: '_dnslink'
-])
diff --git a/config.toml b/config.toml
index 8750846c..15bfcb44 100644
--- a/config.toml
+++ b/config.toml
@@ -1,191 +1,22 @@
-baseURL = "https://docs.libp2p.io"
-relativeURLs = true
-languageCode = "en"
-DefaultContentLanguage = "en"
-enableRobotsTXT=true
-
+baseURL = ""
+languageCode = "en-us"
title = "libp2p Documentation"
-staticDir = ["static", "build"]
-
-[blackfriday]
-hrefTargetBlank = true
+theme = "hugo-theme-learn"
[params]
-editURL = "https://github.com/libp2p/docs/tree/master/content/"
-ordersectionsby = "weight" # ordersectionsby = "title"
+themeVariant = "libp2p"
+disableInlineCopyToClipBoard = true
[outputs]
home = [ "HTML", "RSS", "JSON"]
-[menu]
-
-[[menu.main]]
-identifier = "introduction"
-name = "Introduction"
+[[menu.shortcuts]]
+name = " libp2p.io"
+url = "https://libp2p.io"
weight = 1
-[[menu.main]]
-identifier = "guides"
-name = "Guides"
-weight = 2
-
-[[menu.main]]
-identifier = "reference"
-name = "Reference"
-weight = 3
-
-[[menu.main]]
-identifier = "community"
-name = "Community"
-weight = 4
-
-
-[[menu.reference]]
-identifier = "go_implementation"
-name = "Go Implementation"
-weight = 5
-
-
-[[menu.reference]]
-identifier = "js_implementation"
-name = "JS Implementation"
-weight = 5
-
-[[menu.reference]]
-identifier = "specs"
-name = "Specifications & Planning"
-weight = 6
-[[menu.reference]]
-parent = "specs"
-name = "libp2p Specifications"
-url = "https://github.com/libp2p/specs"
-weight = 20
-
-[[menu.guides]]
-identifier = "guides"
-name = "Guides"
-weight = 3
-[[menu.guides]]
-identifier = "examples"
-name = "Examples"
-weight = 4
-
-
-[[menu.community]]
-identifier = "community"
-name = "Community"
-weight = 9
-[[menu.community]]
-parent = "community"
-name = "Discussion/Support Forum"
-url = "https://discuss.ipfs.io/tags/libp2p"
-weight = 10
-[[menu.community]]
-parent = "community"
-name = "IRC"
-url = "/community/irc/"
-weight = 20
-# [[menu.community]]
-# parent = "community"
-# name = "Research Discussion"
-# url = "https://github.com/ipfs/notes"
-# weight = 30
-# [[menu.community]]
-# parent = "community"
-# name = "Events Calendar"
-# url = "https://calendar.google.com/calendar/embed?src=ipfs.io_eal36ugu5e75s207gfjcu0ae84@group.calendar.google.com"
-# weight = 40
-# [[menu.community]]
-# parent = "community"
-# name = "Community Tools"
-# url = "https://github.com/ipfs/community/"
-# weight = 50
-# [[menu.community]]
-# parent = "community"
-# name = "Project Management"
-# url = "https://github.com/ipfs/pm/"
-# weight = 60
-# [[menu.community]]
-# parent = "community"
-# name = "Blog"
-# url = "https://ipfs.io/blog/"
-# weight = 70
-# [[menu.community]]
-# parent = "community"
-# name = "Youtube"
-# url = "https://www.youtube.com/channel/UCdjsUXJ3QawK4O5L1kqqsew"
-# weight = 80
-# [[menu.community]]
-# parent = "community"
-# name = "Twitter (@IPFSbot)"
-# url = "https://twitter.com/IPFSbot"
-# weight = 90
-# [[menu.community]]
-# parent = "community"
-# name = "Awesome IPFS"
-# url = "https://awesome.ipfs.io/"
-# [[menu.community]]
-# parent = "community"
-# name = "Public Archives on IPFS"
-# title = "A community project to host archives of valuable public data."
-# url = "https://archives.ipfs.io"
-# [[menu.community]]
-# parent="community"
-# name = "FAQ"
-# url = "https://discuss.ipfs.io/c/help/Old-FAQ"
-
-[[menu.community]]
-identifier = "applications"
-name = "Applications"
-weight = 8
-
-
-[[menu.community]]
-identifier = "contribute"
-name = "Get Involved"
-weight = 10
-[[menu.community]]
-parent = "contribute"
-name = "GitHub"
+[[menu.shortcuts]]
+name = " libp2p Github"
url = "https://github.com/libp2p/libp2p"
-weight = 5
-[[menu.community]]
-parent = "contribute"
-name = "Contribution Guidelines"
-url = "https://github.com/libp2p/community/blob/master/CONTRIBUTE.md"
-weight = 10
-[[menu.community]]
-parent = "contribute"
-name = "Code of Conduct"
-url = "https://github.com/ipfs/community/blob/master/code-of-conduct.md"
-weight = 30
-[[menu.community]]
-parent = "contribute"
-name = "Go Style Guide"
-url = "https://github.com/ipfs/community/blob/master/CONTRIBUTING_GO.md"
-weight = 40
-[[menu.community]]
-parent = "contribute"
-name = "JS Style Guide"
-url = "https://github.com/ipfs/community/blob/master/CONTRIBUTING_JS.md"
-weight = 50
-
-[[menu.community]]
-identifier = "related"
-name = "Related Projects"
-[[menu.community]]
-parent = "related"
-name = "IPFS"
-url = "https://ipfs.io"
-weight = 1
-[[menu.community]]
-parent = "related"
-name = "Multiformats"
-url = "https://multiformats.io"
weight = 2
-[[menu.community]]
-parent = "related"
-name = "IPLD"
-url = "https://ipld.io"
-weight = 3
diff --git a/content/_index.md b/content/_index.md
deleted file mode 100644
index a636aba2..00000000
--- a/content/_index.md
+++ /dev/null
@@ -1,57 +0,0 @@
----
-type: index
-title: libp2p Documentation
----
-
-Welcome to the libp2p documentation portal! Whether you’re just learning how to build peer-to-peer systems with libp2p, want to dive into peer-to-peer concepts and solutions, or are looking for detailed reference information, this is the place to start.
-
-## Introduction
-
-Head over to the [introduction](/introduction/) section for an introduction to the basics of libp2p, an overview of the problems it addresses, and a guide to getting up and running.
-
-
-
-## Guides
-
-The guides section has an overview of major concepts in libp2p, guides, and example projects demonstrating various ways to use libp2p to build applications.
-
-In particular, check the [concepts](/guides/concepts/) section to learn more about the major architectural pieces of libp2p and about terms and ideas associated with peer-to-peer systems in general, as well as those specific to libp2p.
-
-
-## Reference
-
-### Implementations
-
-At the core of libp2p is a set of [specifications](https://github.com/libp2p/specs), which together form the definition for what libp2p is in the abstract and what makes a "correct" libp2p implementation. Today, implementations of libp2p exist in several languages, with varying degrees of completeness. The most complete implementations are in [Go](/reference/go/) and [JavaScript](/reference/js/), with [rust](https://github.com/libp2p/rust-libp2p) maturing rapidly.
-
-In addition to the implementations above, the libp2p community is actively working on implementations in [python](https://github.com/libp2p/py-libp2p) and [the JVM via Kotlin](https://github.com/web3j/libp2p). Please check the project pages for each implementation to see its status and current state of completeness.
-
-### Specifications & Planning
-
-While libp2p has several implementations, it is fundamentally a set of protocols for peer identity, discover, routing, transport and more. You can find specifications for those protocols, whitepapers, and information about our RFC (Request for Change) process in the “specifications & planning” section.
-
-
-## Community
-
-Get in touch with other members of the libp2p community who are building tools and applications with libp2p! You can ask questions, discuss new ideas, or get support for problems at https://discuss.ipfs.io, but you can also [hop on IRC](/community/irc/) for a quick chat.
-
-See the other links in the community section for more information about meetings, events, apps people are building, and more.
-
-Information about contributing to libp2p and about other software projects in the community are also hosted here.
-
-
-### Get Involved
-
-libp2p is an open-source community project. While [Protocol Labs](https://protocol.ai) is able to sponsor some of the work around it, much of the design, code, and effort is contributed by volunteers and community members like you. If you’re interested in helping improve libp2p, check the [how to help](/community/contribute/how_to_help/) guide to get started.
-
-If you are diving in to contribute new code, make sure you check both the [contribution guidelines](https://github.com/libp2p/community/blob/master/CONTRIBUTE.md) and the style guide for your language ([Go](https://github.com/ipfs/community/blob/master/CONTRIBUTING_GO.md), [JavaScript](https://github.com/ipfs/community/blob/master/CONTRIBUTING_JS.md)).
-
-
-### Related Projects
-
-libp2p began as part of the [IPFS](https://ipfs.io) project, and is still an essential component of IPFS. As such, libp2p composes well with the abstractions and tools provided by other projects in the IPFS "family". Check their individual sites for specific information and references:
-
-- [IPFS](https://libp2p.io) is the InterPlanetary File System, which uses libp2p as its networking layer.
-- [Multiformats](https://multiformats.io) is a variety of *self-describing* data formats.
-- [IPLD](https://ipld.io) is a set of tools for describing links between content-addressed data, like IPFS files, Git commits, or Ethereum blocks.
-- [The Permissive License Stack](https://protocol.ai/blog/announcing-the-permissive-license-stack) is a licensing strategy for software development that embraces open-source values.
diff --git a/content/community/_index.md b/content/community/_index.md
deleted file mode 100644
index 1aa24703..00000000
--- a/content/community/_index.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-title: "Community"
-headless: true
-opened: true
----
diff --git a/content/community/applications/_index.md b/content/community/applications/_index.md
deleted file mode 100644
index c2872d1c..00000000
--- a/content/community/applications/_index.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-title: "Applications"
-headless: true
-opened: true
----
diff --git a/content/community/applications/built_with_libp2p.md b/content/community/applications/built_with_libp2p.md
deleted file mode 100644
index ef616fdd..00000000
--- a/content/community/applications/built_with_libp2p.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: "Built with libp2p"
-menu:
- community:
- parent: applications
- weight: 1
----
-
-TODO:
-
-- [ ] link to prominent libp2p projects
-- [ ] invite users to add themselves via PR, get in touch
diff --git a/content/community/contribute/_index.md b/content/community/contribute/_index.md
deleted file mode 100644
index 8819740d..00000000
--- a/content/community/contribute/_index.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-title: "Get Involved"
-headless: true
-opened: true
----
diff --git a/content/community/irc.md b/content/community/irc.md
deleted file mode 100644
index 44ef33d4..00000000
--- a/content/community/irc.md
+++ /dev/null
@@ -1,27 +0,0 @@
----
-title: "IRC"
----
-
-The [libp2p channel on Freenode](irc://irc.freenode.org/%23libp2p) is a great place for live chat:
-
-- Use [#libp2p on irc.freenode.org](irc://irc.freenode.org/%23libp2p) to chat with the libp2p community.
-
-For longer-lived discussions and for support, please use the discussion forums at https://discuss.ipfs.io instead of IRC! It’s easy for complex discussions to get lost in a sea of new messages on IRC. Since the discussion board is shared with IPFS and related projects, be sure to tag your threads with the [libp2p tag](https://discuss.ipfs.io/tags/libp2p) to increase its visibility and help people find it.
-
----
-
-If you’re new to IRC, there are *lots* of mobile and desktop clients for working with it. Here are a few to get you started:
-
-- [IRCCloud][irccloud] on the web and desktop
-- [Textual][textual] or [Adium][adium] on Mac OS X
-- [mIRC][mirc] or [HexChat][hexchat] on Windows
-- [XChat][xchat] or [Irssi][irssi] on Linux
-
-
-[adium]: https://adium.im
-[hexchat]: https://hexchat.github.io
-[irccloud]: https://irccloud.com
-[irssi]: https://irssi.org
-[mirc]: http://standaloneinstaller.com/download-mirc
-[textual]: https://www.codeux.com/textual/
-[xchat]: http://xchat.org
diff --git a/content/concepts/_index.md b/content/concepts/_index.md
new file mode 100644
index 00000000..d7ae8ce7
--- /dev/null
+++ b/content/concepts/_index.md
@@ -0,0 +1,16 @@
+---
+title: "Concepts"
+weight: 4
+pre: ' '
+---
+
+libp2p covers a lot of ground, and may involve unfamiliar terminology and concepts.
+This section goes over the foundational concepts involved in libp2p.
+
+{{% children %}}
+
+{{% notice "note" %}}
+This section is incomplete, and many of the articles are stubs. To help fill in
+the gaps, please see the issues linked in each article to add your input and
+help us prioritize the outstanding work.
+{{% /notice %}}
diff --git a/content/concepts/addressing.md b/content/concepts/addressing.md
new file mode 100644
index 00000000..856796ce
--- /dev/null
+++ b/content/concepts/addressing.md
@@ -0,0 +1,8 @@
+---
+title: Addressing
+weight: 6
+---
+
+This article is coming soon!
+
+Please [refer to this issue](https://github.com/libp2p/docs/issues/11) to track the progress and make suggestions.
diff --git a/content/concepts/nat.md b/content/concepts/nat.md
new file mode 100644
index 00000000..7d91786c
--- /dev/null
+++ b/content/concepts/nat.md
@@ -0,0 +1,8 @@
+---
+title: NAT Traversal
+weight: 2
+---
+
+This article is coming soon!
+
+Please [refer to this issue](https://github.com/libp2p/docs/issues/14) to track the progress and make suggestions.
diff --git a/content/concepts/peer-id.md b/content/concepts/peer-id.md
new file mode 100644
index 00000000..3ed5b4a2
--- /dev/null
+++ b/content/concepts/peer-id.md
@@ -0,0 +1,8 @@
+---
+title: Peer Identity
+weight: 4
+---
+
+This article is coming soon!
+
+Please [refer to this issue](https://github.com/libp2p/docs/issues/12) to track the progress and make suggestions.
diff --git a/content/concepts/peer-routing.md b/content/concepts/peer-routing.md
new file mode 100644
index 00000000..4a406b46
--- /dev/null
+++ b/content/concepts/peer-routing.md
@@ -0,0 +1,8 @@
+---
+title: Peer Routing
+weight: 5
+---
+
+This article is coming soon!
+
+Please [refer to this issue](https://github.com/libp2p/docs/issues/13) to track the progress and make suggestions.
diff --git a/content/concepts/protocol-negotiation.md b/content/concepts/protocol-negotiation.md
new file mode 100644
index 00000000..9e3207c2
--- /dev/null
+++ b/content/concepts/protocol-negotiation.md
@@ -0,0 +1,8 @@
+---
+title: Protocol Negotiation
+weight: 3
+---
+
+This article is coming soon!
+
+Please [refer to this issue](https://github.com/libp2p/docs/issues/18) to track the progress and make suggestions.
diff --git a/content/concepts/secure-comms.md b/content/concepts/secure-comms.md
new file mode 100644
index 00000000..c6512a46
--- /dev/null
+++ b/content/concepts/secure-comms.md
@@ -0,0 +1,8 @@
+---
+title: Secure Communication
+weight: 2
+---
+
+This article is coming soon!
+
+Please [refer to this issue](https://github.com/libp2p/docs/issues/19) to track the progress and make suggestions.
diff --git a/content/concepts/stream-multiplexing.md b/content/concepts/stream-multiplexing.md
new file mode 100644
index 00000000..9c310f97
--- /dev/null
+++ b/content/concepts/stream-multiplexing.md
@@ -0,0 +1,5 @@
+---
+title: Stream Multiplexing
+---
+
+This article is coming soon!
diff --git a/content/concepts/transport.md b/content/concepts/transport.md
new file mode 100644
index 00000000..4f2d780c
--- /dev/null
+++ b/content/concepts/transport.md
@@ -0,0 +1,117 @@
+---
+title: Transport
+weight: 1
+---
+
+When you make a connection from your computer to a machine on the internet,
+chances are pretty good you're sending your bits and bytes using TCP/IP, the
+wildly successful combination of the Internet Protocol, which handles addressing
+and delivery of data packets, and the Transmission Control Protocol, which
+ensures that the data that gets sent over the wire is received completely and in
+the right order.
+
+Because TCP/IP is so ubiquitous and well-supported, it's often the default
+choice for networked applications. In some cases, TCP adds too much overhead,
+so applications might use [UDP](https://en.wikipedia.org/wiki/User_Datagram_Protocol),
+a much simpler protocol with no guarantees about reliability or ordering.
+
+While TCP and UDP (together with IP) are the most common protocols in use today,
+they are by no means the only options. Alternatives exist at lower levels
+(e.g. sending raw ethernet packets or bluetooth frames), and higher levels
+(e.g. QUIC, which is layered over UDP).
+
+In libp2p, we call these foundational protocols that move bits around
+**transports**, and one of libp2p's core requirements is to be
+*transport agnostic*. This means that the decision of what transport protocol
+to use is up to the developer, and in fact one application can support many
+different transports at the same time.
+
+## Listening and Dialing
+Transports are defined in terms of two core operations, **listening** and
+**dialing**.
+
+Listening means that you can accept incoming connections from other peers,
+using whatever facility is provided by the
+transport implementation. For example, a TCP transport on a unix platform could
+use the `bind` and `listen` system calls to have the operating system route
+traffic on a given TCP port to the application.
+
+Dialing is the process of opening an outgoing connection to a listening peer.
+Like listening, the specifics are determined by the implementation, but every
+transport in a libp2p implementation will share the same programmatic interface.
+
+## Addresses
+
+Before you can dial up a peer and open a connection, you need to know how to
+reach them. Because each transport will likely require its own address scheme,
+libp2p uses a convention called a "multiaddress" or `multiaddr` to encode
+many different addressing schemes.
+
+The [addressing doc](/concepts/addressing/) goes into more detail, but an overview of
+how multiaddresses work is helpful for understanding the dial and listen
+interfaces.
+
+Here's an example of a multiaddr for a TCP/IP transport:
+
+```
+/ip4/7.7.7.7/tcp/6543
+```
+
+This is equivalent to the more familiar `7.7.7.7:6542` construction, but it
+has the advantage of being explicit about the protocols that are being
+described. With the multiaddr, you can see at a glance that the `7.7.7.7`
+address belongs to the IPv4 protocol, and the `6543` belongs to TCP.
+
+For more complex examples, see [Addressing](/concepts/addressing/).
+
+Both dial and listen deal with multiaddresses. When listening, you give the
+transport the address you'd like to listen on, and when dialing you provide the
+address to dial to.
+
+When dialing a remote peer, the multiaddress should include the
+[PeerId](/concepts/peer-identity/) of the peer you're trying to reach.
+This lets libp2p establish a [secure communication channel](/concepts/secure-comms/)
+and prevents impersonation.
+
+An example multiaddress that includes a `PeerId`:
+
+```
+/ip4/1.2.3.4/tcp/4321/p2p/QmcEPrat8ShnCph8WjkREzt5CPXF2RwhYxYBALDcLC1iV6
+```
+
+The `/p2p/QmcEPrat8ShnCph8WjkREzt5CPXF2RwhYxYBALDcLC1iV6` component uniquely
+identifies the remote peer using the hash of its public key.
+For more, see [Peer Identity](/concepts/peer-id/).
+
+{{% notice "tip" %}}
+
+When [peer routing](/concepts/peer-routing/) is enabled, you can dial peers
+using just their PeerId, without needing to know their transport addresses
+before hand.
+
+{{% /notice %}}
+
+## Supporting multiple transports
+
+libp2p applications often need to support multiple transports at once. For
+example, you might want your services to be usable from long-running daemon
+processes via TCP, while also accepting websocket connections from peers running
+in a web browser.
+
+The libp2p component responsible for managing the transports is called the
+[switch][definition_switch], which also coordinates
+[protocol negotiation](/concepts/protocol-negotiation),
+[stream multiplexing](/concepts/stream-multiplexing),
+[establishing secure communication](/concepts/secure-comms/) and other forms of
+"connection upgrading".
+
+The switch provides a single "entry point" for dialing and listening, and frees
+up your application code from having to worry about the specific transports
+and other pieces of the "connection stack" that are used under the hood.
+
+{{% notice "note" %}}
+The term "swarm" was previously used to refer to what is now called the "switch",
+and some places in the codebase still use the "swarm" terminology.
+{{% /notice %}}
+
+[definition_switch]: /reference/glossary/#switch
diff --git a/content/community/contribute/how_to_help.md b/content/contributing/_index.md
similarity index 98%
rename from content/community/contribute/how_to_help.md
rename to content/contributing/_index.md
index 485ef794..e9207d32 100644
--- a/content/community/contribute/how_to_help.md
+++ b/content/contributing/_index.md
@@ -1,9 +1,7 @@
---
-title: "How to Help"
-menu:
- community:
- parent: contribute
- weight: 1
+title: Contributing
+weight: 10
+pre: ' '
---
So you want to contribute to libp2p and the peer-to-peer ecosystem? Here is a quick listing
diff --git a/content/examples/_index.md b/content/examples/_index.md
new file mode 100644
index 00000000..487742e3
--- /dev/null
+++ b/content/examples/_index.md
@@ -0,0 +1,11 @@
+---
+title: Examples
+weight: 3
+pre: ' '
+---
+
+Here's where to find working examples illustrating some of libp2p's key features for each of its main implementations:
+
+* For go, see the [go-libp2p-examples repo](https://github.com/libp2p/go-libp2p-examples).
+* For javascript, see the [/examples directory of the js-libp2p repo](https://github.com/libp2p/js-libp2p/tree/master/examples).
+* For rust, see [/examples directory of the rust-libp2p repo](https://github.com/libp2p/rust-libp2p/tree/master/examples).
diff --git a/content/guides/_index.md b/content/guides/_index.md
deleted file mode 100644
index e69de29b..00000000
diff --git a/content/guides/concepts/_index.md b/content/guides/concepts/_index.md
deleted file mode 100644
index 12177dd9..00000000
--- a/content/guides/concepts/_index.md
+++ /dev/null
@@ -1,11 +0,0 @@
----
-title: "Concepts"
-menu:
- guides:
- identifier: concepts
- weight: 2
----
-
-This will soon be the home of in-depth "concept articles" exploring the peer-to-peer problem space and libp2p's approach to solving some of the problems within.
-
-Please [file an issue](https://github.com/libp2p/docs/issues/new) if there's a concept you especially want included.
diff --git a/content/guides/examples/_index.md b/content/guides/examples/_index.md
deleted file mode 100644
index e1f3ddfb..00000000
--- a/content/guides/examples/_index.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: Basic Examples
-layout: examples
-menu:
- guides:
- parent: examples
- weight: 2
----
-
-This will soon be the home of introductory examples and tutorials for using libp2p.
-
-While in-depth examples are under-construction, the [go-libp2p-examples repository](https://github.com/libp2p/go-libp2p-examples) contains several go-specific code samples and tutorials.
-
-
-Please [file an issue](https://github.com/libp2p/docs/issues/new) if you have ideas for examples that would be especially helpful.
diff --git a/content/introduction/_index.md b/content/introduction/_index.md
index 17c38379..f8ccc7e6 100644
--- a/content/introduction/_index.md
+++ b/content/introduction/_index.md
@@ -1,9 +1,60 @@
---
-title: "Introduction"
-headless: true
-opened: true
-# menu:
-# docs:
-# identifier: section:start
-# weight: 1
+title: Introduction
+weight: 1
+pre: ' '
---
+
+Welcome to the libp2p documentation portal! Whether you’re just learning how to build peer-to-peer systems with libp2p, want to dive into peer-to-peer concepts and solutions, or are looking for detailed reference information, this is the place to start.
+
+## Overview
+
+Head over to [What is libp2p?](/introduction/what-is-libp2p/) for an introduction to the basics of libp2p and an overview of the problems it addresses.
+
+
+## Tutorials
+
+If you want to dive in, check out our collection of [tutorials](/tutorials/), which will help guide you through your explorations of libp2p.
+
+## Examples
+
+If you want to get a feel for what's possible with libp2p, or just want to see some idiomatic usage, check out the [examples](/examples/). Each libp2p implementation maintains a set of working example projects that can illustrate key concepts and use cases.
+
+## Reference
+
+### Specifications & Planning
+
+While libp2p has several implementations, it is fundamentally a set of protocols for peer identity, discover, routing, transport and more.
+
+See the [specifications section](/reference/specifications/)
+
+### Implementations
+
+At the core of libp2p is a set of [specifications](https://github.com/libp2p/specs), which together form the definition for what libp2p is in the abstract and what makes a "correct" libp2p implementation. Today, implementations of libp2p exist in several languages, with varying degrees of completeness. The most complete implementations are in [Go](/reference/go/) and [JavaScript](/reference/js/), with [rust](https://github.com/libp2p/rust-libp2p) maturing rapidly.
+
+In addition to the implementations above, the libp2p community is actively working on implementations in [python](https://github.com/libp2p/py-libp2p) and [the JVM via Kotlin](https://github.com/web3j/libp2p). Please check the project pages for each implementation to see its status and current state of completeness.
+
+
+## Community
+
+Get in touch with other members of the libp2p community who are building tools and applications with libp2p! You can ask questions, discuss new ideas, or get support for problems at https://discuss.ipfs.io, but you can also [hop on IRC](/community/irc/) for a quick chat.
+
+See the other links in the community section for more information about meetings, events, apps people are building, and more.
+
+Information about contributing to libp2p and about other software projects in the community are also hosted here.
+
+
+### Get Involved
+
+libp2p is an open-source community project. While [Protocol Labs](https://protocol.ai) is able to sponsor some of the work around it, much of the design, code, and effort is contributed by volunteers and community members like you. If you’re interested in helping improve libp2p, check the [how to help](/community/contribute/how_to_help/) guide to get started.
+
+If you are diving in to contribute new code, make sure you check both the [contribution guidelines](https://github.com/libp2p/community/blob/master/CONTRIBUTE.md) and the style guide for your language ([Go](https://github.com/ipfs/community/blob/master/CONTRIBUTING_GO.md), [JavaScript](https://github.com/ipfs/community/blob/master/CONTRIBUTING_JS.md)).
+
+
+### Related Projects
+
+libp2p began as part of the [IPFS](https://ipfs.io) project, and is still an essential component of IPFS. As such, libp2p composes well with the abstractions and tools provided by other projects in the IPFS "family". Check their individual sites for specific information and references:
+
+- [IPFS](https://libp2p.io) is the InterPlanetary File System, which uses libp2p as its networking layer.
+- [Multiformats](https://multiformats.io) is a variety of *self-describing* data formats.
+- [IPLD](https://ipld.io) is a set of tools for describing links between content-addressed data, like IPFS files, Git commits, or Ethereum blocks.
+- [The Permissive License Stack](https://protocol.ai/blog/announcing-the-permissive-license-stack) is a licensing strategy for software development that embraces open-source values.
diff --git a/content/introduction/what-is-libp2p.md b/content/introduction/what-is-libp2p.md
index c2e98b80..9ad809ec 100644
--- a/content/introduction/what-is-libp2p.md
+++ b/content/introduction/what-is-libp2p.md
@@ -1,8 +1,6 @@
---
title: "What is libp2p?"
-menu:
- introduction:
- weight: 1
+weight: 2
---
Good question! The one-liner pitch is that libp2p is a modular system of *protocols*, *specifications* and *libraries* that enable the development of peer-to-peer network applications.
@@ -58,7 +56,11 @@ In some systems, we care less about who we're speaking with than we do about wha
libp2p provides a [content routing interface][interface_content_routing] for this purpose, with the primary stable implementation using the same [Kademlia][wiki_kademlia]-based DHT as used in peer routing.
+### Messaging / PubSub
+Sending messages to other peers is at the heart of most peer-to-peer systems, and pubsub (short for publish / subscribe) is a very useful pattern for sending a message to groups of interested receivers.
+
+libp2p defines a [pubsub interface][interface_pubsub] for sending messages to all peers subscribed to a given "topic". The interface currently has two stable implementations; `floodsub` uses a very simple but inefficient "network flooding" strategy, and [gossipsub](https://github.com/libp2p/specs/tree/master/pubsub/gossipsub) defines an extensible gossip protocol. There is also active development in progress on [episub](https://github.com/libp2p/specs/blob/master/pubsub/gossipsub/episub.md), an extended `gossipsub` that is optimized for single source multicast and scenarios with a few fixed sources broadcasting to a large number of clients in a topic.
[glossary]: {{< ref "/reference/glossary.md" >}}
[definition_dht]: {{< ref "/reference/glossary.md#dht" >}}
@@ -70,8 +72,10 @@ libp2p provides a [content routing interface][interface_content_routing] for thi
[definition_client_server]: {{< ref "/reference/glossary.md#client-server" >}}
[interface_content_routing]: https://github.com/libp2p/interface-content-routing
+[interface_pubsub]: https://github.com/libp2p/specs/tree/master/pubsub
+
-[built_with_libp2p]: {{< ref "/community/applications/built_with_libp2p.md" >}}
-[help_improve_docs]: {{< ref "/community/contribute/how_to_help.md" >}}
+[built_with_libp2p]: /TODO
+[help_improve_docs]: /TODO
[wiki_kademlia]: https://en.wikipedia.org/wiki/Kademlia
diff --git a/content/reference/_index.md b/content/reference/_index.md
index c9741a69..728c81d4 100644
--- a/content/reference/_index.md
+++ b/content/reference/_index.md
@@ -1,6 +1,9 @@
---
-type: page
-title: "Reference"
-headless: true
-opened: true
+title: Reference
+weight: 5
+pre: ' '
---
+
+This section contains in-depth reference material, including a [glossary](/reference/glossary/) with definitions of libp2p terminology.
+
+Please help make this section more complete by [filing an issue](https://github.com/libp2p/docs/issues/new).
diff --git a/content/reference/glossary.md b/content/reference/glossary.md
index 6e5fd23b..4f3ec17f 100644
--- a/content/reference/glossary.md
+++ b/content/reference/glossary.md
@@ -1,8 +1,6 @@
---
title: "Glossary"
-menu:
- reference:
- weight: 1
+weight: 1
---
### Circuit Relay
@@ -29,7 +27,9 @@ libp2p uses the DHT as the foundation for one of its [peer routing](#peer-routin
### Connection
-TODO: define libp2p connection & link to interface-connection. Link to multiplexing.
+A libp2p connection is a communication channel that allows peers to read and write data.
+
+Connections between peers are established via [transports](#transport), which can be thought of as "connection factories". For example, the TCP transport allows you to create connections that use TCP/IP as their underlying substrate.
### Dial
@@ -89,6 +89,12 @@ Multiplexing allows peers to offer many [protocols](#protocol) over a single con
Applications built with libp2p get multiplexing "for free" via the [mplex specification](https://github.com/libp2p/specs/tree/master/mplex).
+### multistream
+
+[multistream](https://github.com/multiformats/multistream) is a lightweight convention for "tagging" streams of binary data with a short header that identifies the content of the stream.
+
+libp2p uses multistream to identify the [protocols](#protocol) used for communication between peers, and a related project [multistream-select](https://github.com/multiformats/multistream-select) is used for [protocol negotiation](#protocol-negotiation).
+
### NAT
[Network address translation](https://en.wikipedia.org/wiki/Network_address_translation) in general is the mapping of addresses from one address space to another, as often happens at the boundary of private networks with the global internet. It is especially essential in IPv4 networks (which are still the vast majority), as the address space of IPv4 is quite limited. Using NAT, a local, private network can have a vast range of addresses within the internal network, while only consuming one public IP address from the global pool.
@@ -100,16 +106,17 @@ This is less of an issue in a client / server model, because outgoing connection
In the peer-to-peer model, accepting connections from other peers is often just as important as initiating them, which means that we often need our peers to be publicly reachable from the global internet. There are many viable approaches to [NAT Traversal](#nat-traversal), several of which are implemented in libp2p.
### NAT Traversal
+
+
NAT traversal refers to the process of establishing connections with other machines across a [NAT](#nat) boundary. When crossing the boundary between IP networks (e.g. from a local network to the global internet), a [Network Address Translation](#nat) process occurs which maps addresses from one space to another.
For example, my home network has an internal range of IP addresses (10.0.1.x), which is part of a range of addresses that are reserved for private networks. If I start a program on my computer that listens for connections on its internal address, a user from the public internet has no way of reaching me, even if they know my public IP address. This is because I haven't made my router aware of my program yet. When a connection comes in from the internet to my public IP address, the router needs to figure out which internal IP to route the request to, and to which port.
-There are many ways to inform one's router about services you want to expose. For consumer routers, there's likely an admin interface that can setup mappings for any range of TCP or UDP ports. In many cases, routers will allow automatic registration of ports using a protocol called [upnp](https://en.wikipedia.org/wiki/Universal_Plug_and_Play), which libp2p supports. If enabled, libp2p will try to register your service with the router for automatic NAT traversal.
+There are many ways to inform one's router about services you want to expose. For consumer routers, there's likely an admin interface that can setup mappings for any range of TCP or UDP ports. In many cases, routers will allow automatic registration of ports using a protocol called [upnp](https://en.wikipedia.org/wiki/Universal_Plug_and_Play), which libp2p supports. If enabled, libp2p will try to register your service with the router for automatic NAT traversal.
In some cases, automatic NAT traversal is impossible, often because multiple layers of NAT are involved. In such cases, we still want to be able to communicate, and we especially want to be reachable and allow other peers to [dial in](#dial) and use our services. This is the one of the motivations for [Circuit Relay](#circuit-relay), which is a protocol involving a "relay" peer that is publicly reachable and can route traffic on behalf of others. Once a relay circuit is established, a peer behind an especially intractable NAT can advertise the relay circuit's [multiaddress](#multiaddress), and the relay will accept incoming connections on our behalf and send us traffic via the relay.
-
### Node
@@ -150,7 +157,7 @@ An important property of cryptographic peer identities is that they are decouple
### Peer store
-TODO: link to spec, implementations in JS & Go
+A data structure that stores [PeerIds](#peerid) for known peers, along with known [multiaddresses](#multiaddress) that can be used to communicate with them.
### Peer routing
@@ -168,7 +175,17 @@ libp2p defines a [pubsub spec](https://github.com/libp2p/specs/blob/master/pubsu
### Protocol
-TODO: define what we mean by "libp2p protocol", protocol handlers, etc. link to [multiplexing](#multiplexing).
+In general, a set of rules and data structures used for network communication.
+
+libp2p is comprised of many protocols and makes use of many others provided by
+the operating system or runtime environment.
+
+Most core libp2p functionality is defined in terms of protocols, and libp2p
+protocols are identified using [multistream](#multistream) headers.
+
+### Protocol Negotiation
+
+
### Stream
@@ -180,7 +197,24 @@ TODO: Distinguish between the various types of "stream". Could refer to
### Swarm
-TODO: define swarm in libp2p context
+Can refer to a collection of interconnected peers.
+
+In the libp2p codebase, "swarm" may refer to a module that allows a peer to
+interact with its peers, although this component was later renamed ["switch"](#switch).
+
+See [the discussion about the name change](https://github.com/libp2p/js-libp2p-switch/issues/40)
+for context.
+
+### Switch
+
+A libp2p component responsible for composing multiple [tranports](#tranport)
+into a single interface, allowing application code to [dial](#dial) peers
+without having to specify what transport to use.
+
+In addition to managing transports, the switch also coordinates the
+"connection upgrade" process, which is used to provide
+
+Sometimes called ["swarm"](#swarm) for historical reasons.
### Topology
@@ -193,4 +227,4 @@ In libp2p, `transport` refers to the technology that lets us move bits from one
Note that in some environments such as javascript running in the browser, not all transports will be available. In such cases, it may be possible to establish a [Circuit Relay](#circuit-relay) with the help of a peer that can support many common transports. Such a relay can act as a "transport adapter" of sorts, allowing peers that can't communicate with each other directly to interact. For example, a peer in the browser that can only make websocket connections could relay through a peer able to make TCP connections, which would enable communication with a wider variety of peers.
-[js-docs-home]: {{< ref "/reference/js" >}}
+[js-docs-home]: /reference/
diff --git a/content/reference/go/_index.md b/content/reference/go/_index.md
deleted file mode 100644
index 34ad4ef8..00000000
--- a/content/reference/go/_index.md
+++ /dev/null
@@ -1,4 +0,0 @@
----
-title: "Go Implementation"
-headless: true
----
diff --git a/content/reference/go/go-libp2p.md b/content/reference/go/go-libp2p.md
deleted file mode 100644
index 5fe48107..00000000
--- a/content/reference/go/go-libp2p.md
+++ /dev/null
@@ -1,25 +0,0 @@
----
-title: "Working with libp2p in Go"
-menu:
- reference:
- parent: go_implementation
- weight: 1
----
-
-Coming soon!
-
-
diff --git a/content/reference/js/_index.md b/content/reference/js/_index.md
deleted file mode 100644
index 47505c29..00000000
--- a/content/reference/js/_index.md
+++ /dev/null
@@ -1,4 +0,0 @@
----
-title: "JS Implementation"
-headless: true
----
diff --git a/content/reference/js/js-libp2p.md b/content/reference/js/js-libp2p.md
deleted file mode 100644
index 518a91c5..00000000
--- a/content/reference/js/js-libp2p.md
+++ /dev/null
@@ -1,28 +0,0 @@
----
-title: "Working with libp2p in JS"
-menu:
- reference:
- parent: js_implementation
- weight: 1
----
-
-Coming soon!
-
-
diff --git a/content/reference/specs.md b/content/reference/specs.md
new file mode 100644
index 00000000..d40f4181
--- /dev/null
+++ b/content/reference/specs.md
@@ -0,0 +1,8 @@
+---
+title: Specifications
+weight: 2
+---
+
+Check out the [specs repo](https://github.com/libp2p/specs) for details about the libp2p architecture.
+
+
diff --git a/content/reference/specs/working_groups.md b/content/reference/specs/working_groups.md
deleted file mode 100644
index 0ab39dc3..00000000
--- a/content/reference/specs/working_groups.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Working Groups
-draft: true
-menu:
- reference:
- parent: specs
----
-
-The design IPFS protocols and implementation of reference software are all managed by a variety of working groups. You can learn more about our governing structure in [RFC 0002](https://github.com/ipfs/rfcs/blob/8e2587cec2ebd3e585cb1cb78bd4df18024428c3/rfcs/0002-ipfs-governance.md). Active working groups are:
-
-- TODO: Document existing working groups, their processes, and where work/discussion happens.
-- Should this wait for https://github.com/ipfs/rfcs/pull/2 ?
diff --git a/content/tutorials/_index.md b/content/tutorials/_index.md
new file mode 100644
index 00000000..e621185b
--- /dev/null
+++ b/content/tutorials/_index.md
@@ -0,0 +1,10 @@
+---
+title: Tutorials
+weight: 2
+pre: ' '
+---
+
+
+Here you'll find step-by-step tutorials for using libp2p in your favorite languages.
+
+{{% children description="true" %}}
diff --git a/content/tutorials/getting-started/_index.md b/content/tutorials/getting-started/_index.md
new file mode 100644
index 00000000..a8aeb59e
--- /dev/null
+++ b/content/tutorials/getting-started/_index.md
@@ -0,0 +1,11 @@
+---
+title: "Getting Started"
+weight: 1
+---
+
+This tutorial covers setting up your development environment, getting familiar with some libp2p basics, and implementing a super simple node that can send and receive "ping" messages.
+
+
+
+{{% children description="true" %}}
+-----
diff --git a/content/tutorials/getting-started/go.md b/content/tutorials/getting-started/go.md
new file mode 100644
index 00000000..5287bddb
--- /dev/null
+++ b/content/tutorials/getting-started/go.md
@@ -0,0 +1,9 @@
+---
+title: "Getting Started with go-libp2p"
+menuTitle: Go
+weight: 1
+---
+
+This article is coming soon!
+
+Please [refer to this issue](https://github.com/libp2p/docs/issues/16) to track the progress and make suggestions.
diff --git a/content/tutorials/getting-started/javascript.md b/content/tutorials/getting-started/javascript.md
new file mode 100644
index 00000000..efbf7059
--- /dev/null
+++ b/content/tutorials/getting-started/javascript.md
@@ -0,0 +1,322 @@
+---
+title: "Getting Started with js-libp2p"
+menuTitle: "Javascript"
+weight: 2
+---
+
+This is the first in a series of tutorials on working with libp2p's javascript implementation, [js-libp2p](https://github.com/libp2p/js-libp2p).
+
+We'll cover setting up an empty project, creating a libp2p "bundle" with some basic functionality, and finally we'll send ping messages back and forth between two peers.
+
+
+
+
+
+## Install node.js
+
+Working with js-libp2p requires [node.js](https://nodejs.org) for development. If you haven't already, install node using whatever package manager you prefer or [using the official installer](https://nodejs.org/en/download/).
+
+We recommend using the latest stable version of node, but anything fairly recent should work fine. If you want to see how low you can go, the current version requirements can always be found at the [js-libp2p project page](https://github.com/libp2p/js-libp2p).
+
+## Create an empty project
+
+We need a place to put our work, so open a terminal to make a new directory for your project somewhere and set it up as an npm project:
+
+```shell
+# create a directory for the project and `cd` into it
+> mkdir hello-libp2p
+> mkdir hello-libp2p/src
+> cd hello-libp2p
+
+# make it a git repository
+> git init .
+
+# make it an npm project. fill in the prompts with info for your project
+# when asked for your project's entry point, enter "src/index.js"
+> npm init
+```
+
+Side note: throughout this tutorial, we use the `> ` character to indicate your terminal's shell prompt. When following along, don't type the `>` character, or you'll get some weird errors.
+
+
+## Build a libp2p bundle
+
+libp2p is a very modular framework, which allows javascript devs to target different runtime environments and opt-in to various features by including a custom selection of modules.
+
+Because every application is different, we recommend building a "bundle" with just the modules you need. You can even make more than one, if you want to target multiple javascript runtimes with different features. For example, the IPFS project uses two libp2p bundles, [one for node.js](https://github.com/ipfs/js-ipfs/tree/master/src/core/runtime/libp2p-nodejs.js) and [one for the browser](https://github.com/ipfs/js-ipfs/tree/master/src/core/runtime/libp2p-browser.js).
+
+Since, we're here to learn how libp2p works, we're going to start from scratch and define our own bundle. We'll start with a very simple bundle and add features as we need them.
+
+First, install the `libp2p` dependency. We'll also need at least one transport module, so we'll pull in `libp2p-tcp` as well, and the `@nodeutils/defaults-deep` helper which we'll use when building the bundle.
+
+```shell
+npm install --save libp2p libp2p-tcp @nodeutils/defaults-deep
+```
+
+{{% notice note %}}
+In a production application, it may make sense to create a separate npm module for your bundle, which will give you one place to manage the libp2p dependencies for all your javascript projects. In that case, you should not depend on `libp2p` directly in your application. Instead you'd depend on your bundle, which would in turn depend on `libp2p` and whatever modules (transports, etc) you might need.
+{{% /notice %}}
+
+For this tutorial, our bundle will just be a javascript file in our application source.
+
+Make a directory called `src/p2p` and a file called `src/p2p/index.js` with the following content:
+
+```javascript
+const Libp2p = require('libp2p')
+const TCP = require('libp2p-tcp')
+
+const defaultsDeep = require('@nodeutils/defaults-deep')
+
+const DEFAULT_OPTS = {
+ modules: {
+ transport: [
+ TCP
+ ]
+ }
+}
+
+class P2PNode extends Libp2p {
+ constructor (opts) {
+ super(defaultsDeep(opts, DEFAULT_OPTS))
+ }
+}
+
+```
+
+The `libp2p` module exports a [libp2p.Node class](https://github.com/libp2p/js-libp2p#create-a-node---new-libp2pnodeoptions) which we extend into our own `P2PNode` class.
+
+Right now our class just adds the `libp2p-tcp` transport module to the default constructor options of the base class. As we go, we'll extend our bundle to include more transports and configure other aspects of the libp2p stack.
+
+## Create an instance of a libp2p node
+
+Using the bundle we defined above, we can create a new `P2PNode` instance.
+
+To do so, create a file called `src/index.js` and make it look like this:
+
+```javascript
+const multiaddr = require('multiaddr')
+const PeerInfo = require('peer-info')
+const {P2PNode} = require('./p2p')
+
+function createPeer(callback) {
+ // create a new PeerInfo object with a newly-generated PeerId
+ PeerInfo.create((err, peerInfo) => {
+ if (err) {
+ return callback(err)
+ }
+
+ // add a listen address to accept TCP connections on a random port
+ const listenAddress = multiaddr(`/ip4/127.0.0.1/tcp/0`)
+ peerInfo.multiaddrs.add(listenAddress)
+
+ const peer = new P2PNode({peerInfo})
+ // register an event handler for errors.
+ // here we're just going to print and re-throw the error
+ // to kill the program
+ peer.on('error', err => {
+ console.error('libp2p error: ', err)
+ throw err
+ })
+
+ callback(null, peer)
+ })
+}
+```
+
+We start out by importing a few modules. Apart from the `P2PNode` bundle we defined earlier, we have `multiaddr`, the javascript [multiaddress][definition_muiltiaddress] library, and `peer-info`, which contains a [PeerId][definition_peerid] and a set of multiaddresses that are associated with a peer.
+
+The constructor for our bundle requires a `peerInfo` argument. This can either be generated on-the-fly or loaded from a byte buffer or JSON object. In our `createPeer` function, we're generating a new `PeerInfo` object for our peer using [`PeerInfo.create`](https://github.com/libp2p/js-peer-info#peerinfocreateid--callback). This will generate a new `PeerId` containing a newly-generated cryptographic key pair.
+
+{{% notice note %}}
+Because generating the key pair requires some computation, `PeerInfo.create` is an asynchronous operation. libp2p uses node-style callbacks for most asynchronous operations, and real-world code and more complex examples will often use helpers like [async/waterfall](https://caolan.github.io/async/docs.html#waterfall) to compose chains of async operations. Since this is a fairly simple example, we're just going to use the callbacks as-is and chain them together the "old fashioned way".
+{{% /notice %}}
+
+Once we have our `PeerInfo`, we next create a [multiaddress][definition_muiltiaddress] for `/ip4/127.0.0.1/tcp/0`, which is the [localhost IPv4 address](https://en.wikipedia.org/wiki/Localhost) on the special TCP port `0`. Using port `0` tells the operating system to randomly assign us an open port.
+
+Adding the new multiaddr to our `PeerInfo` object will cause our node to try to listen on that address when the node starts.
+
+Next we create our peer, passing in the `peerInfo` constructor option, and we register a simple error handler to catch errors that might occur during the lifetime of our peer.
+
+## Start the node and listen for connections
+
+Now we can call the `createPeer` function above and start listening for connections.
+
+Just below the `createPeer` function definition, add some code to start the peer and print our listening address:
+
+```javascript
+function handleStart(peer) {
+ // get the list of addresses for our peer now that it's started.
+ // there should be one address of the form
+ // `/ip4/127.0.0.1/tcp/${assignedPort}/ipfs/${generatedPeerId}`,
+ // where `assignedPort` is randomly chosen by the operating system
+ // and `generatedPeerId` is generated in the `createPeer` function above.
+ const addresses = peer.peerInfo.multiaddrs.toArray()
+ console.log('peer started. listening on addresses:')
+ addresses.forEach(addr => console.log(addr.toString()))
+}
+
+
+// main entry point
+createPeer((err, peer) => {
+ if (err) {
+ throw err
+ }
+
+ peer.start(err => {
+ if (err) {
+ throw err
+ }
+
+ handleStart(peer)
+ })
+})
+```
+
+Try running the code with `node src/index.js`. You should see something like:
+
+```
+peer started. listening on addresses:
+/ip4/127.0.0.1/tcp/54093/ipfs/QmPfH3qx5fyfUgxacrZ1WNC1GwXmY5kWzns3Fc9KAwZRgJ
+```
+
+Each time you run the program, you should see a different tcp port number and PeerId hash (the `QmPfH3qx5fyfUgxacrZ1WNC1GwXmY5kWzns3Fc9KAwZRgJ` string above).
+
+## Add multiplexing and encryption
+
+We can now start a node and listen for connections, but we can't really do anything yet. This is because we're missing a key libp2p component called a [stream multiplexer][definition_multiplexer], which lets us interleave multiple independent streams of communication across one network connection.
+
+While we're at it, we'll also add support for encrypted communication, which is something most real-world applications will need to support.
+
+Lets add two new dependencies:
+
+```shell
+npm install --save libp2p-mplex libp2p-secio
+```
+
+And we'll need to edit our bundle. Open `src/p2p/index.js` and import the new modules:
+
+```javascript
+const Multiplex = require('libp2p-mplex')
+const SECIO = require('libp2p-secio')
+```
+
+Then change the `DEFAULT_OPTS` constant to look like this:
+
+```javascript
+const DEFAULT_OPTS = {
+ modules: {
+ transport: [
+ TCP
+ ],
+ connEncryption: [
+ SECIO
+ ],
+ streamMuxer: [
+ Multiplex
+ ]
+ }
+}
+```
+
+Thats it! Now we can open multiple independent streams over our single TCP connection, and our connection will be upgraded to a securely encrypted channel using the [secio module](https://github.com/libp2p/js-libp2p-secio).
+
+## Lets play ping pong!
+
+Now that we have the basic building blocks of transport, multiplexing, and security in place, we can start communicating!
+
+The base `libp2p.Node` class that we based our bundle on registers one built-in protocol handler for us, the [ping protocol](https://github.com/libp2p/js-libp2p-ping). That means that other peers can dial us and send us ping messages, and we'll send back a "pong" so they know we're alive and can measure the latency between us.
+
+While we respond to pings automatically, we need to do a bit of wiring to send them.
+
+Let's add a `ping` method to our `P2PNode` class so we can send pings to other peers.
+
+Change the definition of `P2PNode` in `src/p2p/index.js` to this:
+
+```javascript
+class P2PNode extends Libp2p {
+ constructor (opts) {
+ super(defaultsDeep(opts, DEFAULT_OPTS))
+ }
+
+ ping (remotePeerInfo, callback) {
+ const p = new Ping(this._switch, remotePeerInfo)
+ p.on('ping', time => {
+ p.stop() // stop sending pings
+ callback(null, time)
+ })
+ p.on('error', callback)
+ p.start()
+ }
+}
+```
+
+Now we can accept have our program accept the multiaddress of another peer as a command line argument and try to ping it.
+
+To do so, we'll need to add a couple things to `src/index.js`. First, require the `process` module so we can get the command line arguments:
+
+```javascript
+const process = require('process')
+```
+
+Then we'll add a function to parse a multiaddress from the command line and try to ping the remote peer:
+
+```javascript
+function pingRemotePeer(localPeer) {
+ if (process.argv.length < 3) {
+ return console.log('no remote peer address given, skipping ping')
+ }
+ const remoteAddr = multiaddr(process.argv[2])
+
+ // Convert the multiaddress into a PeerInfo object
+ const peerId = PeerId.createFromB58String(addr.getPeerId())
+ const remotePeerInfo = new PeerInfo(peerId)
+ remotePeerInfo.multiaddrs.add(addr)
+
+ console.log('pinging remote peer at ', remoteAddr.toString())
+ localPeer.ping(remotePeerInfo, (err, time) => {
+ if (err) {
+ return console.error('error pinging: ', err)
+ }
+ console.log(`pinged ${remoteAddr.toString()} in ${time}ms`)
+ })
+}
+```
+
+And finally, in our `handleStart` function, just after we log our listen address, add this line:
+
+```javascript
+pingRemotePeer(peer)
+```
+
+Now we can start one instance with no arguments:
+
+```shell
+> node src/index.js
+peer started. listening on addresses:
+/p2p-circuit/ipfs/QmcJWZQ3Q1q9jUwzYw1e1NN2oQG2kGocru62oGAnh4HMGL
+/p2p-circuit/ip4/127.0.0.1/tcp/0/ipfs/QmcJWZQ3Q1q9jUwzYw1e1NN2oQG2kGocru62oGAnh4HMGL
+/ip4/127.0.0.1/tcp/55780/ipfs/QmcJWZQ3Q1q9jUwzYw1e1NN2oQG2kGocru62oGAnh4HMGL
+no remote peer address given, skipping ping
+```
+
+Grab the `/ip4/...` address printed above and use it as an argument to another instance. In a new terminal:
+
+```shell
+> node src/index.js /ip4/127.0.0.1/tcp/55780/ipfs/QmcJWZQ3Q1q9jUwzYw1e1NN2oQG2kGocru62oGAnh4HMGL
+peer started. listening on addresses:
+/p2p-circuit/ipfs/QmWXirJ9QoSnXpEAqVeEFtEAwcP8oufg1bBV2dSH41B2yt
+/p2p-circuit/ip4/127.0.0.1/tcp/0/ipfs/QmWXirJ9QoSnXpEAqVeEFtEAwcP8oufg1bBV2dSH41B2yt
+/ip4/127.0.0.1/tcp/55800/ipfs/QmWXirJ9QoSnXpEAqVeEFtEAwcP8oufg1bBV2dSH41B2yt
+pinging remote peer at /ip4/127.0.0.1/tcp/55780/ipfs/QmcJWZQ3Q1q9jUwzYw1e1NN2oQG2kGocru62oGAnh4HMGL
+pinged /ip4/127.0.0.1/tcp/55780/ipfs/QmcJWZQ3Q1q9jUwzYw1e1NN2oQG2kGocru62oGAnh4HMGL in 6ms
+```
+
+Success! Our two peers are now communicating over a multiplexed, secure channel. Sure, they can only say "ping", but it's a start!
+
+
+
+[definition_muiltiaddress]: /reference/glossary/#multiaddress
+[definition_multiplexer]: /reference/glossary/#multiplexer
+[definition_peerid]: /reference/glossary/#peerid
diff --git a/layouts/404.html b/layouts/404.html
deleted file mode 100644
index e69de29b..00000000
diff --git a/layouts/_default/baseof.html b/layouts/_default/baseof.html
deleted file mode 100644
index 19cb2345..00000000
--- a/layouts/_default/baseof.html
+++ /dev/null
@@ -1,36 +0,0 @@
-
-
-
-
-
-
-
-
- {{ .Title }}{{ if not .IsHome }} – {{ .Site.Title }}{{ end }}
- {{ with .Site.Params.description }}{{ end }}
- {{ with .Site.Params.author }}{{ end }}
-
- {{ with .Site.Title }}{{ end }}
- {{ with .Site.Params.logo }}{{ end }}
- {{ with .Site.Title }}{{ end }}
-
-
-
-
-
-
-
-
-