◉ COOLJAPAN
← All posts
January 19, 2026 • 6 min read

IPFRS 0.1.0 Released — A Pure Rust InterPlanetary File System That Understands Your Data

IPFRS — Inter-Planet File RUST System — debuts at 0.1.0: a Pure Rust, content-addressed distributed file system with Sled-backed block storage, DAG-CBOR/IPLD, an HNSW semantic search index, and TensorLogic logic programming. Local-first, ~4,417 lines, 8 crates.

release ipfrs ipfs content-addressing ipld semantic-search pure-rust distributed

Content addressing is how the next web remembers things — so we built it in Pure Rust, and taught it to understand what it stores.

Today we released IPFRS 0.1.0 — the Foundation Release of the Inter-Planet File RUST System, a Pure Rust, content-addressed distributed file system with block storage, IPLD DAGs, semantic vector search, and logic programming baked into one node.

No C. No Go. No Fortran. No CGo bridges, no node-gyp, no daemon written in a garbage-collected language that you have to babysit. IPFS today means go-ipfs / Kubo (a heavyweight Go daemon) or js-ipfs (a sprawling JavaScript stack); the libp2p incumbents underneath are Go and C. IPFRS owes them the ideas — CIDs, IPLD, the content-addressed worldview — and owes them nothing else. It compiles to a single static binary (or WASM) and runs everywhere a Rust toolchain reaches: servers, edge boxes, embedded devices, the browser.

Why IPFRS 0.1.0 matters

Classic IPFS is, at heart, a static file warehouse. It addresses bytes by their hash and hands them back. That is genuinely powerful — but it has no idea what those bytes mean, and the reference implementation is a large Go daemon you have to run beside everything else.

IPFRS 0.1.0 keeps the content-addressed core honest and adds two things the warehouse never had:

This is a deliberately local-first release. There is no real P2P networking yet — that is the road ahead. What ships here is solid, tested, and production-ready for local and single-node use.

Technical Deep Dive: four layers, eight crates

IPFRS is a workspace. The unified ipfrs facade sits on top of focused crates: ipfrs-core, ipfrs-storage, ipfrs-network, ipfrs-transport, ipfrs-semantic, ipfrs-interface, ipfrs-tensorlogic, and ipfrs-cli (with ipfrs-python, built via maturin, kept out of the default members).

1. Content-addressed block storage (ipfrs-storage). Blocks live in a Sled embedded database, addressed by CID. The async API covers put, get, has, delete, batched put_many / get_many, file operations (add_file, get_to_file, add_bytes, get_range), directory operations, and block_stat / block_rm. Serialization runs on oxicode, the COOLJAPAN serializer.

2. IPLD DAGs (ipfrs-core). DAG-CBOR nodes give you a real Merkle-DAG: dag_put, dag_get, dag_resolve to navigate IPLD paths like /key1/key2/0, and dag_traverse doing a BFS with cycle detection. IPLD values cover Maps, Lists, Links, Bytes, Integers, and Strings.

3. Semantic search (ipfrs-semantic). The HNSW index powers index_content(), search_similar() for approximate k-NN, and search_hybrid() with a QueryFilter (min_score, max_results, cid_prefix). Distance metrics include Cosine, L2, and DotProduct, with LRU query caching and semantic_stats() for introspection.

4. Logic programming (ipfrs-tensorlogic). A TensorLogic store with content-addressed IR: put_term() / get_term() over Variable / Constant / Compound terms, store_predicate / get_predicate, and store_rule / get_rule (head plus body), all JSON-serializable. infer() is a deliberate placeholder here — the foundation for distributed reasoning arriving in 0.2.0.

Above all of this sits the Node API: a builder-pattern NodeConfig, start() / stop(), Arc + RwLock thread safety, and the ability to switch off semantic search or TensorLogic when you do not need them.

Getting Started

IPFRS requires Rust 1.70 or later. Build from source and install the CLI:

git clone https://github.com/cool-japan/ipfrs
cd ipfrs
cargo install --path crates/ipfrs-cli

Then drive it from the command line:

ipfrs init
ipfrs add myfile.txt        # -> CID: bafybeig...
ipfrs cat bafybeig...
ipfrs stats

Or embed the ipfrs library directly:

use ipfrs::{Node, NodeConfig};

#[tokio::main]
async fn main() -> ipfrs::Result<()> {
    let mut node = Node::new(NodeConfig::default())?;
    node.start().await?;

    let cid = node.add_bytes(b"Hello, IPFRS!").await?;
    println!("Added: {}", cid);

    if let Some(block) = node.get(&cid).await? {
        println!("Retrieved: {:?}", block.data());
    }

    Ok(())
}

What’s inside

Tips

This is the foundation

IPFRS is the content-addressed storage layer of the COOLJAPAN ecosystem. It already leans on OxiCode (oxicode) for serialization, and it lands alongside a fast-growing Pure Rust family — the same-day cohort of amaters, celers, kaccy, kizzasi, and oxify, following earlier arrivals like oxiarc, oxifft, and oxiz, the chie and mielin pair, legalis, the scirs / numrs / optirs / pandrs scientific stack, oxiblas, and voirs. Local-first today; a real distributed network is next.

Repository: https://github.com/cool-japan/ipfrs

Star the repo if a Pure Rust IPFS that understands its own contents sounds like the future you want to build on. Pure Rust content-addressed storage is here — fast, safe, and sovereign.

— KitaSan at COOLJAPAN OÜ January 19, 2026

↑ Back to all posts