Convert Figma logo to code with AI

ipfs logokubo

An IPFS implementation in Go

16,006
2,997
16,006
1,162
View on GitHub

Top Related Projects

ipfs's avatar

kubo

16,006

An IPFS implementation in Go

libp2p's avatar

go-libp2p

6,038

libp2p implementation in Go

ipfs's avatar

js-ipfs

7,436

IPFS implementation in JavaScript

ipfs's avatar

ipfs-desktop

5,938

An unobtrusive and user-friendly desktop application for IPFS on Windows, Mac and Linux.

ipfs-cluster's avatar

ipfs-cluster

1,473

Pinset orchestration for IPFS

storj's avatar

storj

2,972

Ongoing Storj v3 development. Decentralized cloud object storage that is affordable, easy to use, private, and secure.

Quick Overview

Kubo (formerly go-ipfs) is the main implementation of the InterPlanetary File System (IPFS) protocol, written in Go. It provides a decentralized, peer-to-peer network for storing and sharing files, websites, and other data across the internet without relying on centralized servers.

Pros

  • Decentralized and distributed, enhancing data availability and resilience
  • Content-addressed storage, ensuring data integrity and deduplication
  • Supports various use cases, from file sharing to decentralized websites
  • Active development and community support

Cons

  • Learning curve for users unfamiliar with decentralized systems
  • Performance can be slower compared to traditional centralized systems
  • Requires running a node, which may be resource-intensive for some users
  • Limited adoption compared to traditional file-sharing methods

Code Examples

  1. Adding a file to IPFS:
import "github.com/ipfs/kubo/core/coreapi"

ipfs, _ := coreapi.NewIPFS(ctx)
path, _ := ipfs.Unixfs().Add(ctx, strings.NewReader("Hello, IPFS!"))
fmt.Println(path.String()) // Outputs: /ipfs/QmXXX...
  1. Retrieving a file from IPFS:
import "github.com/ipfs/kubo/core/coreapi"

ipfs, _ := coreapi.NewIPFS(ctx)
node, _ := ipfs.Unixfs().Get(ctx, path.New("/ipfs/QmXXX..."))
content, _ := io.ReadAll(node.(files.File))
fmt.Println(string(content)) // Outputs: Hello, IPFS!
  1. Pinning content:
import "github.com/ipfs/kubo/core/coreapi"

ipfs, _ := coreapi.NewIPFS(ctx)
path := path.New("/ipfs/QmXXX...")
err := ipfs.Pin().Add(ctx, path)
if err != nil {
    fmt.Println("Failed to pin:", err)
}

Getting Started

To get started with Kubo:

  1. Install Go (version 1.16 or later)
  2. Clone the repository: 
    git clone https://github.com/ipfs/kubo.git
  3. Build and install: 
    cd kubo
make install
  4. Run IPFS daemon: 
    ipfs daemon

For more detailed instructions and usage examples, refer to the project's documentation and README.

Competitor Comparisons

ipfs logo

kubo

16,006

An IPFS implementation in Go

Pros of kubo

  • More established and mature project with a larger community
  • Extensive documentation and resources available
  • Wider range of features and functionality

Cons of kubo

  • Potentially more complex and resource-intensive
  • May have a steeper learning curve for newcomers
  • Could be slower to implement new experimental features

Code Comparison

kubo:

type Config struct {
    Identity  identity.Identity
    Datastore repo.Datastore
    Addresses config.Addresses
    Mounts    Mounts
    Discovery Discovery
    Routing   Routing
    // ... (additional fields)
}

There is no meaningful code comparison available for this scenario, as both repositories refer to the same project. The kubo repository is the main implementation of the IPFS protocol, and there isn't a separate "kubo>" repository to compare it against.

Summary

The comparison between kubo and kubo> is not applicable, as they refer to the same project. kubo (previously known as go-ipfs) is the main implementation of the InterPlanetary File System (IPFS) protocol. It's a mature, feature-rich project with a large community and extensive documentation. While it offers a wide range of functionality, it may be more complex and resource-intensive compared to alternative IPFS implementations. The project continues to evolve and improve, balancing stability with the introduction of new features.

libp2p logo

go-libp2p

6,038

libp2p implementation in Go

Pros of go-libp2p

  • More focused and modular, specifically for networking and peer-to-peer communication
  • Easier to integrate into other projects due to its standalone nature
  • More flexible and customizable for specific use cases

Cons of go-libp2p

  • Less feature-rich compared to Kubo's full IPFS implementation
  • Requires more setup and configuration for full IPFS functionality
  • May have a steeper learning curve for developers new to p2p networking

Code Comparison

go-libp2p:

host, err := libp2p.New(
    libp2p.ListenAddrStrings("/ip4/0.0.0.0/tcp/0"),
    libp2p.Identity(priv),
)

Kubo:

node, err := core.NewNode(ctx, &core.BuildCfg{
    Online: true,
    Repo:   repo,
})

go-libp2p focuses on creating a p2p host, while Kubo initializes a full IPFS node. go-libp2p provides more granular control over network configuration, whereas Kubo offers a higher-level abstraction for IPFS functionality.

ipfs logo

js-ipfs

7,436

IPFS implementation in JavaScript

Pros of js-ipfs

  • JavaScript-based, allowing easy integration with web applications and Node.js projects
  • Lightweight and suitable for browser environments
  • Supports running IPFS nodes directly in web browsers

Cons of js-ipfs

  • Generally slower performance compared to Kubo
  • Less feature-complete than Kubo
  • May have limitations in handling large-scale data or high-throughput scenarios

Code Comparison

Kubo (Go):

node, err := core.NewNode(ctx, &core.BuildCfg{
    Online: true,
    Repo:   repo,
})

js-ipfs (JavaScript):

const node = await IPFS.create({
  repo: 'ok' + Math.random(),
  config: { Addresses: { Swarm: [] } }
})

Both examples demonstrate node creation, but Kubo uses Go's error handling pattern, while js-ipfs uses JavaScript's Promise-based async/await syntax. Kubo's implementation tends to offer more low-level control, while js-ipfs provides a more JavaScript-friendly API.

js-ipfs is ideal for web-based projects and quick prototyping, offering easier integration with JavaScript ecosystems. However, for high-performance, feature-rich applications, Kubo remains the more robust choice, benefiting from Go's performance advantages and a more extensive feature set.

ipfs logo

ipfs-desktop

5,938

An unobtrusive and user-friendly desktop application for IPFS on Windows, Mac and Linux.

Pros of IPFS Desktop

  • User-friendly graphical interface for managing IPFS nodes
  • Easy installation and setup for non-technical users
  • Integrates IPFS functionality into the desktop environment

Cons of IPFS Desktop

  • Limited customization options compared to Kubo
  • May have higher resource usage due to GUI overhead
  • Fewer advanced features for power users

Code Comparison

IPFS Desktop (JavaScript):

const { start } = require('ipfs-desktop')

start({
  // Configuration options
})

Kubo (Go):

package main

import (
    "fmt"
    "github.com/ipfs/kubo/core"
)

func main() {
    node, err := core.NewNode(ctx, &core.BuildCfg{})
    // Error handling and node operations
}

Summary

IPFS Desktop provides a more accessible entry point for users new to IPFS, offering a graphical interface and simplified setup. However, it sacrifices some of the flexibility and advanced features found in Kubo. Kubo, being the reference implementation of IPFS, offers more control and customization options but requires more technical knowledge to set up and use effectively. The choice between the two depends on the user's needs and technical expertise.

ipfs-cluster logo

ipfs-cluster

1,473

Pinset orchestration for IPFS

Pros of ipfs-cluster

  • Designed for collaborative pinning and data orchestration across multiple IPFS nodes
  • Provides advanced features like replication factor control and pinset management
  • Offers a more scalable solution for large-scale IPFS deployments

Cons of ipfs-cluster

  • Adds complexity to the IPFS setup, requiring additional configuration and maintenance
  • May introduce overhead in terms of resource usage compared to a single Kubo node
  • Has a smaller community and ecosystem compared to Kubo

Code Comparison

Kubo (Go):

node, err := core.NewNode(ctx, &core.BuildCfg{
    Online: true,
    Routing: libp2p.DHTOption,
})

ipfs-cluster (Go):

cluster, err := ipfscluster.NewCluster(
    ctx,
    host,
    cfg,
    consensus,
    api,
    ipfs,
    tracker,
    monitor,
    allocator,
    informer,
    tracer,
)

Both projects are written in Go, but ipfs-cluster's initialization involves more components, reflecting its focus on cluster management and coordination.

storj logo

storj

2,972

Ongoing Storj v3 development. Decentralized cloud object storage that is affordable, easy to use, private, and secure.

Pros of Storj

  • Offers a decentralized cloud storage solution with encryption and sharding
  • Implements a token-based economy for incentivizing storage providers
  • Focuses on enterprise-grade reliability and performance

Cons of Storj

  • Less widespread adoption compared to IPFS ecosystem
  • More complex setup and management for individual users
  • Limited content addressing capabilities

Code Comparison

Storj (Go):

func (db *DB) Get(ctx context.Context, bucket []byte, key []byte) (_ []byte, err error) {
    defer mon.Task()(&ctx)(&err)
    return db.db.Get(bucket, key)
}

IPFS/Kubo (Go):

func (n *IpfsNode) Get(ctx context.Context, p path.Path) (ipld.Node, error) {
    return n.Resolver.ResolveOnce(ctx, p)
}

Both projects use Go and implement similar get functions, but Storj focuses on bucket/key storage, while IPFS uses content-addressed paths.

Convert Figma logo designs to code with AI

Visual Copilot

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README


Kubo logo
Kubo: IPFS Implementation in GO

The first implementation of IPFS.

Official Part of IPFS Project Discourse Forum Matrix ci GitHub release godoc reference

What is Kubo?

Kubo was the first IPFS implementation and is the most widely used one today. Implementing the Interplanetary Filesystem - the Web3 standard for content-addressing, interoperable with HTTP. Thus powered by IPLD's data models and the libp2p for network communication. Kubo is written in Go.

Featureset

Other implementations

See List

What is IPFS?

IPFS is a global, versioned, peer-to-peer filesystem. It combines good ideas from previous systems such as Git, BitTorrent, Kademlia, SFS, and the Web. It is like a single BitTorrent swarm, exchanging git objects. IPFS provides an interface as simple as the HTTP web, but with permanence built-in. You can also mount the world at /ipfs.

For more info see: https://docs.ipfs.tech/concepts/what-is-ipfs/

Before opening an issue, consider using one of the following locations to ensure you are opening your thread in the right place:

YouTube Channel Subscribers Follow @IPFS on Twitter

Next milestones

Milestones on GitHub

Table of Contents

Security Issues

Please follow SECURITY.md.

Minimal System Requirements

IPFS can run on most Linux, macOS, and Windows systems. We recommend running it on a machine with at least 4 GB of RAM and 2 CPU cores (kubo is highly parallel). On systems with less memory, it may not be completely stable, and you run on your own risk.

Install

The canonical download instructions for IPFS are over at: https://docs.ipfs.tech/install/. It is highly recommended you follow those instructions if you are not interested in working on IPFS development.

Docker

Official images are published at https://hub.docker.com/r/ipfs/kubo/:

Docker Image Version (latest semver)

  • 🟢 Releases
  • 🟠 We also provide experimental developer builds
    • master-latest always points at the HEAD of the master branch
    • master-YYYY-DD-MM-GITSHA points at a specific commit from the master branch
    • These tags are used by developers for internal testing, not intended for end users or production use.
$ docker pull ipfs/kubo:latest
$ docker run --rm -it --net=host ipfs/kubo:latest

To customize your node, pass necessary config via -e or by mounting scripts in the /container-init.d.

Learn more at https://docs.ipfs.tech/install/run-ipfs-inside-docker/

Official prebuilt binaries

The official binaries are published at https://dist.ipfs.tech#kubo:

dist.ipfs.tech Downloads

From there:

  • Click the blue "Download Kubo" on the right side of the page.
  • Open/extract the archive.
  • Move kubo (ipfs) to your path (install.sh can do it for you).

If you are unable to access dist.ipfs.tech, you can also download kubo (go-ipfs) from:

Updating

Using ipfs-update

IPFS has an updating tool that can be accessed through ipfs update. The tool is not installed alongside IPFS in order to keep that logic independent of the main codebase. To install ipfs-update tool, download it here.

Downloading builds using IPFS

List the available versions of Kubo (go-ipfs) implementation:

$ ipfs cat /ipns/dist.ipfs.tech/kubo/versions

Then, to view available builds for a version from the previous command ($VERSION):

$ ipfs ls /ipns/dist.ipfs.tech/kubo/$VERSION

To download a given build of a version:

$ ipfs get /ipns/dist.ipfs.tech/kubo/$VERSION/kubo_$VERSION_darwin-386.tar.gz    # darwin 32-bit build
$ ipfs get /ipns/dist.ipfs.tech/kubo/$VERSION/kubo_$VERSION_darwin-amd64.tar.gz  # darwin 64-bit build
$ ipfs get /ipns/dist.ipfs.tech/kubo/$VERSION/kubo_$VERSION_freebsd-amd64.tar.gz # freebsd 64-bit build
$ ipfs get /ipns/dist.ipfs.tech/kubo/$VERSION/kubo_$VERSION_linux-386.tar.gz     # linux 32-bit build
$ ipfs get /ipns/dist.ipfs.tech/kubo/$VERSION/kubo_$VERSION_linux-amd64.tar.gz   # linux 64-bit build
$ ipfs get /ipns/dist.ipfs.tech/kubo/$VERSION/kubo_$VERSION_linux-arm.tar.gz     # linux arm build
$ ipfs get /ipns/dist.ipfs.tech/kubo/$VERSION/kubo_$VERSION_windows-amd64.zip    # windows 64-bit build

Unofficial Linux packages

Packaging status

Arch Linux

kubo via Community Repo

# pacman -S kubo

kubo-git via AUR

Gentoo Linux

https://wiki.gentoo.org/wiki/Kubo

# emerge -a net-p2p/kubo

https://packages.gentoo.org/packages/net-p2p/kubo

Nix

With the purely functional package manager Nix you can install kubo (go-ipfs) like this:

$ nix-env -i kubo

You can also install the Package by using its attribute name, which is also kubo.

Solus

Package for Solus

$ sudo eopkg install kubo

You can also install it through the Solus software center.

openSUSE

Community Package for go-ipfs

Guix

Community Package for go-ipfs is no out-of-date.

Snap

No longer supported, see rationale in kubo#8688.

Ubuntu PPA

PPA homepage on Launchpad.

Latest Ubuntu (>= 20.04 LTS)
sudo add-apt-repository ppa:twdragon/ipfs
sudo apt update
sudo apt install ipfs-kubo
Any Ubuntu version
sudo su
echo 'deb https://ppa.launchpadcontent.net/twdragon/ipfs/ubuntu <<DISTRO>> main' >> /etc/apt/sources.list.d/ipfs
echo 'deb-src https://ppa.launchpadcontent.net/twdragon/ipfs/ubuntu <<DISTRO>> main' >> /etc/apt/sources.list.d/ipfs
exit
sudo apt update
sudo apt install ipfs-kubo

where <<DISTRO>> is the codename of your Ubuntu distribution (for example, jammy for 22.04 LTS). During the first installation the package maintenance script may automatically ask you about which networking profile, CPU accounting model, and/or existing node configuration file you want to use.

NOTE: this method also may work with any compatible Debian-based distro which has libc6 inside, and APT as a package manager.

Unofficial Windows packages

Chocolatey

No longer supported, see rationale in kubo#9341.

Scoop

Scoop provides kubo as kubo in its 'extras' bucket.

PS> scoop bucket add extras
PS> scoop install kubo

Unofficial macOS packages

MacPorts

The package ipfs currently points to kubo (go-ipfs) and is being maintained.

$ sudo port install ipfs

Nix

In macOS you can use the purely functional package manager Nix:

$ nix-env -i kubo

You can also install the Package by using its attribute name, which is also kubo.

Homebrew

A Homebrew formula ipfs is maintained too.

$ brew install --formula ipfs

Build from Source

GitHub go.mod Go version

kubo's build system requires Go and some standard POSIX build tools:

  • GNU make
  • Git
  • GCC (or some other go compatible C Compiler) (optional)

To build without GCC, build with CGO_ENABLED=0 (e.g., make build CGO_ENABLED=0).

Install Go

GitHub go.mod Go version

If you need to update: Download latest version of Go.

You'll need to add Go's bin directories to your $PATH environment variable e.g., by adding these lines to your /etc/profile (for a system-wide installation) or $HOME/.profile:

export PATH=$PATH:/usr/local/go/bin
export PATH=$PATH:$GOPATH/bin

(If you run into trouble, see the Go install instructions).

Download and Compile IPFS

$ git clone https://github.com/ipfs/kubo.git

$ cd kubo
$ make install

Alternatively, you can run make build to build the go-ipfs binary (storing it in cmd/ipfs/ipfs) without installing it.

NOTE: If you get an error along the lines of "fatal error: stdlib.h: No such file or directory", you're missing a C compiler. Either re-run make with CGO_ENABLED=0 or install GCC.

Cross Compiling

Compiling for a different platform is as simple as running:

make build GOOS=myTargetOS GOARCH=myTargetArchitecture

Troubleshooting

  • Separate instructions are available for building on Windows.
  • git is required in order for go get to fetch all dependencies.
  • Package managers often contain out-of-date golang packages. Ensure that go version reports at least 1.10. See above for how to install go.
  • If you are interested in development, please install the development dependencies as well.
  • Shell command completions can be generated with one of the ipfs commands completion subcommands. Read docs/command-completion.md to learn more.
  • See the misc folder for how to connect IPFS to systemd or whatever init system your distro uses.

Getting Started

Usage

docs: Command-line quick start docs: Command-line reference

To start using IPFS, you must first initialize IPFS's config files on your system, this is done with ipfs init. See ipfs init --help for information on the optional arguments it takes. After initialization is complete, you can use ipfs mount, ipfs add and any of the other commands to explore!

Some things to try

Basic proof of 'ipfs working' locally:

echo "hello world" > hello
ipfs add hello
# This should output a hash string that looks something like:
# QmT78zSuBmuS4z925WZfrqQ1qHaJ56DQaTfyMUF7F8ff5o
ipfs cat <that hash>

HTTP/RPC clients

For programmatic interaction with Kubo, see our list of HTTP/RPC clients.

Troubleshooting

If you have previously installed IPFS before and you are running into problems getting a newer version to work, try deleting (or backing up somewhere else) your IPFS config directory (~/.ipfs by default) and rerunning ipfs init. This will reinitialize the config file to its defaults and clear out the local datastore of any bad entries.

Please direct general questions and help requests to our forums.

If you believe you've found a bug, check the issues list and, if you don't see your problem there, either come talk to us on Matrix chat, or file an issue of your own!

Packages

See IPFS in GO documentation.

Development

Some places to get you started on the codebase:

Map of Implemented Subsystems

WIP: This is a high-level architecture diagram of the various sub-systems of this specific implementation. To be updated with how they interact. Anyone who has suggestions is welcome to comment here on how we can improve this!

CLI, HTTP-API, Architecture Diagram

Origin

Description: Dotted means "likely going away". The "Legacy" parts are thin wrappers around some commands to translate between the new system and the old system. The grayed-out parts on the "daemon" diagram are there to show that the code is all the same, it's just that we turn some pieces on and some pieces off depending on whether we're running on the client or the server.

Testing

make test

Development Dependencies

If you make changes to the protocol buffers, you will need to install the protoc compiler.

Developer Notes

Find more documentation for developers on docs

Maintainer Info

Kubo is maintained by Shipyard.

Contributing

We ❤️ all our contributors; this project wouldn’t be what it is without you! If you want to help out, please see CONTRIBUTING.md.

This repository falls under the IPFS Code of Conduct.

Members of IPFS community provide Kubo support on discussion forum category here.

Need help with IPFS itself? Learn where to get help and support at https://ipfs.tech/help.

License

This project is dual-licensed under Apache 2.0 and MIT terms: