Kubo is the reference implementation of IPFS, the InterPlanetary File System, built for Windows users who want to run their own node in a decentralized storage network. It was the first IPFS implementation and remains the most widely used one, which makes it the natural starting point for anyone new to IPFS.
The program is free and open source under the Apache 2.0 license, and its source code is published on GitHub. The latest version is v0.43.1, and the most recent code update on the project page is dated September 27, 2026, a sign that development is active. Kubo is command-line first with a built-in web interface, so it suits developers, archivists and privacy-minded users more than people looking for a point-and-click app.
What Is IPFS and Why Content Addressing Matters
Most of the web works by location: you ask a specific server for a specific path, and if that server goes offline, the file disappears from your view. IPFS takes a different approach. Files are addressed by their content, so the address is derived from the data itself.
Kubo generates content identifiers, or CIDs, from the data and organizes larger files into a graph of linked blocks called a DAG. Directories and files are described through UnixFS, which lets the same content be recognized and fetched by any peer that holds it. If two people add the same file, the identifier matches, so the network does not need to store two different copies under two different addresses.
This model is useful for documents, datasets, software builds and static websites that should stay reachable regardless of which machine currently hosts them. It does not make content permanent on its own, since a file remains available only while some node keeps it. Understanding that trade-off is the first step to using Kubo well.
Who Kubo Is For and Realistic Use Cases
Kubo fits people who want to work with IPFS directly rather than through a hosted service. Developers building decentralized apps use it as a local test node, so they can add content, check how it resolves and debug retrieval before deploying anything.
Archivists and researchers use it to publish collections of documents or datasets under stable content identifiers. A journal, a research group or a small team can share the CID of a file, and anyone with access to a gateway or a connected peer can retrieve the same bytes. Because the identifier is tied to the content, the link remains valid even if the original upload location changes.
Privacy-minded users sometimes run a node to participate in the network on their own terms, with a local repository and a local web interface. Students learning distributed systems also benefit, because Kubo exposes the underlying concepts through commands they can run and inspect. Each of these groups gets value from the same program, though the depth of setup they need will differ.
Kubo and the Wider IPFS Ecosystem
Kubo is often described as the most widely used IPFS implementation, and that position shapes how it works with other tools. Its design takes a deliberately conservative approach to content addressing, so that data created by Kubo can be read by other compatible software. Interoperability is the main goal, and it is why standard formats like UnixFS and standard transfer methods matter.
Data moves between nodes through Bitswap and HTTP. Bitswap is the peer-to-peer exchange used between IPFS nodes, while HTTP lets browsers and simple tools fetch content without joining the network directly. For reproviding content to the Amino DHT, a node must have enough memory for the pinset it announces, which is why operators of large nodes plan their hardware carefully.
In practice this means a Kubo node can work alongside desktop tray apps, browser-based tools and command-line pinning utilities. Choosing Kubo as the core engine gives you the widest compatibility, while other programs in the catalog wrap the same network in different interfaces.
Key features
Command-line interface
Built-in WebUI
HTTP Gateway
HTTP RPC API
HTTP Routing V1 client and server
FUSE mounts (experimental)
Content blocking for public nodes
Supported coins
Kubo is not a cryptocurrency client and does not handle coins, tokens or wallets. Its networking is built around the IPFS network, where content is exchanged with peers over Bitswap and HTTP, and where the Amino DHT is used for reproviding content. The assets it works with are files, directories and content identifiers rather than digital currencies.
How to install Kubo (IPFS) on Windows
- 1
Download the Windows build or installer
Get the ready-made Windows package from the project's official website or the GitHub Releases page for ipfs/kubo. Pick the latest release, which is currently v0.43.1. Download only from the official website or the GitHub Releases page, never from mirror sites or file aggregators.
- 2
Verify the file
Compare the SHA-256 checksum of the downloaded file with the value published alongside the release. If a signature is provided, check that as well. A mismatch means the file should be discarded and downloaded again from the official source.
- 3
Run the installer or extract the build
If you received an installer, run it and follow the prompts. If you got a plain Windows build, extract the archive to a folder you control and place the ipfs executable where your terminal can find it. Keeping it in a dedicated folder makes updates easier to manage.
- 4
Confirm the command works
Open a new terminal window and run ipfs --help. A list of subcommands confirms that the program is installed and reachable from the command line. If the command is not recognized, check that the folder containing the executable is included in your PATH setting.
-
Initialize your node
Run ipfs init once. This creates the local repository where your node keeps its configuration, its identity and the blocks it stores. You only need to do this for a new setup, so later sessions can start straight from the daemon.
System requirements
- Runs on most Windows systems, as well as most Linux and macOS systems
- At least 6 GB of RAM is recommended for good performance
- At least 2 CPU cores are recommended, and more helps because Kubo is highly parallel
- Larger pinsets need additional memory, estimated at about 1 GiB of RAM per 20 million items for reproviding to the Amino DHT
How to use Kubo (IPFS)
Once Kubo is installed, a few commands cover the basics of running a node and sharing a file. The workflow below assumes you are working in a Windows terminal.
- Open a terminal and run
ipfs initif you have not initialized the node yet. - Start the node with
ipfs daemonand leave that window open while the node runs. - Add a file with
ipfs add report.pdf. The command prints a content identifier (CID) for the file. - Open the WebUI in your browser to check the node status and see the content it holds.
- Share the CID with a colleague or friend. They can open it through an HTTP gateway, or fetch it directly from your node while it is online.
- Keep the file available by leaving the node running, and stop the daemon with Ctrl+C in its terminal when you are finished.
Adding a file does not automatically guarantee that others can always reach it. Content stays retrievable as long as at least one node holds it and announces it, so a node that is switched off for long periods will not keep your files visible to the network.
Pros & cons
- Free and open source under the Apache 2.0 license
- The first and most widely used IPFS implementation
- Command-line tool, WebUI, HTTP gateway and RPC API in one program
- Recent code update and a current release, v0.43.1
- Source code is public on GitHub, so it can be reviewed
- The command-line focus means a learning curve for beginners
- FUSE mounts are still marked experimental
- Larger pinsets need substantial additional memory
- Running a node puts your machine on the network, which may need attention on a home connection
- Understanding content identifiers takes time before the model feels natural
Is Kubo (IPFS) safe?
Kubo is open source under the Apache 2.0 license, and its source code is public, which makes independent review possible. The project is not deprecated, and its latest code update is recent. Still, you should take a few precautions. Download the program only from the official website or the GitHub Releases page, and verify the SHA-256 checksum or signature before running it. Keep the repository folder private, because it holds your node identity. Avoid exposing the RPC API to the internet, and do not share your repository or configuration files with anyone. Kubo does not hold coins or ask for a seed phrase, so any website that requests one while claiming to be Kubo is not the project. Check the latest version on the official website before updating.
- Official source only. Download from github.com/ipfs/kubo. Ignore ads and lookalike domains.
- Check the SHA-256. Compare the installer hash with the value the developer publishes before running it.
- Never share your seed phrase. No developer, support agent or website — including CryptApps — will ever ask for it.
Alternatives
Kubo is the full command-line program that runs an IPFS node, with a WebUI and gateway included. IPFS Desktop takes a more casual approach by placing a node in the system tray, which suits people who want to start a node without using a terminal. Storj is a decentralized cloud storage network with its own model, so it competes with IPFS on the idea of distributed storage rather than on protocol compatibility. Peergos focuses on end-to-end encrypted file storage and sharing between peers, while Pinner CLI is a narrower tool for pinning content. ZeroNet and Agregore take different routes to decentralized sites and browsing. Kubo stands out for being the reference implementation, so it is the most direct route to the IPFS protocol itself.
Specifications
- Price
- Free
- Type
- Open source
- License
- Apache 2.0
- Latest version
- v0.43.1
- Last update
- 27 Sept 2026
- Windows support
- Yes (Windows build or installer)
- Source code
- github.com/ipfs/kubo
Frequently asked questions
Kubo is open source under the Apache 2.0 license, and it is safe to install when you take it from the project's own download pages and verify its SHA-256 checksum. Its source code is public, so independent developers can review it. Avoid unofficial copies, since a modified build could carry malware.
IPFS, the InterPlanetary File System, is a peer-to-peer protocol for storing and sharing files by their content rather than by server location. Kubo is the most widely used program that runs an IPFS node. Each file receives a content identifier, so the same data can be fetched from any peer that holds it.
Yes, Kubo is free. It is open source under the Apache 2.0 license, so you can use it personally or in a business and read the source code on GitHub. Check the license terms if you plan to redistribute modified versions.
The project recommends at least 6 GB of RAM and 2 CPU cores for good performance, and more cores help because the program is highly parallel. Larger pinsets need additional memory, estimated at around 1 GiB for every 20 million items reprovided to the Amino DHT.
Yes, Kubo includes a WebUI for managing a running node in your browser. The main way to control it is the command-line interface, which is also available through an HTTP RPC API for scripts and applications. Choose whichever suits your workflow.
No. Kubo is a storage and networking program for IPFS, not a cryptocurrency, wallet or miner. It does not hold coins or tokens, so there is no balance to protect. Its main security concerns are the local node identity and any network ports you choose to expose.
Yes. Add a file with the ipfs add command, copy the resulting content identifier, and send it to someone. They can open it through an HTTP gateway, or fetch it from your node while the node is online and holding the file.
Yes, Kubo is listed as available in Docker alongside Windows, macOS and Linux. A native Windows build or installer is the simpler route for most desktop users, while a container suits people who already manage their services with Docker.
Verdict
Kubo is the right choice for Windows users who want to run a genuine IPFS node and understand how it works. It is free, open source and actively maintained, and it offers a command-line tool, a WebUI, a gateway and an RPC API in one program. Developers, archivists and technically curious users will get the most from it. If you prefer a tray app or a simple file-sharing interface, a wrapper program from this catalog may suit you better, though most of them still rely on the same network underneath.