Arkaprabha Banerjee

Posted on Mar 19 • Originally published at blogagent-production-d2b2.up.railway.app

Wander – A Tiny, Decentralised Tool to Explore the Small Web (2025)

#decentralizedweb #activitypub #fediverse #rustwebassembly

Originally published at https://blogagent-production-d2b2.up.railway.app/blog/wander-a-tiny-decentralised-tool-to-explore-the-small-web-2025

The web we once loved is fading. Centralized platforms dominate our social lives, but a quiet revolution is brewing in the fediverse. Wander, a lightweight, open-source tool for developers, is at the forefront of this movement.

Wander – A Tiny, Decentralised Tool to Explore the Small Web

What is the Small Web and Why Should Developers Care?

The small web refers to the decentralized, user-owned network of platforms like Mastodon, PeerTube, and PixelFed. Unlike Twitter or Facebook, these services federate content across servers, giving users control over their data and algorithms. As of 2025, over 30 million users actively participate in the fediverse, creating a vibrant ecosystem of niche communities — but navigating it remains a technical challenge.

This is where Wander shines. Designed for developers and privacy advocates, Wander acts as a universal explorer for the small web. At just 500KB, it’s written in Rust (compiled to WebAssembly) and integrates cutting-edge protocols like ActivityPub, Webfinger, and WebRTC. Its minimalist design makes it ideal for building decentralized apps or managing federated content.

Technical Deep Dive: How Wander Works

ActivityPub Federation at the Core

Wander leverages the ActivityPub protocol to interact with federated services. Here’s a simplified example of how it fetches a user’s followers:

async function fetchActivityPubFeed(actorUrl) {
  const response = await fetch(`${actorUrl}/followers`, {
    headers: { Accept: 'application/ld+json' }
  });
  const followers = await response.json();
  return followers.map(f => fetch(f.actor).then(r => r.json()));
}

This code demonstrates how Wander bypasses centralized APIs, directly querying the decentralized graph. It uses JSON-LD for structured data and supports pagination for large user networks.

Rust + WebAssembly: Performance Meets Portability

Wander’s Rust backend ensures robust performance, while WebAssembly enables seamless cross-platform execution. The team employs wasm-bindgen for Rust-JavaScript interop:

#[wasm_bindgen]
pub fn init_plugin(proto: &str) -> JsValue {
  match proto {
    "matrix" => JsValue::from_serde(&serde_json::json!({
      "endpoint": "https://matrix.org",
      "auth": "oidc"
    })),
    _ => JsValue::NULL
  }
}

This modular design allows developers to add support for new protocols (e.g., Matrix, DAT) without rewriting the core application.

Key Features for Developers

1. Decentralized Identity via Webfinger + DID

Wander authenticates users using Webfinger and Decentralized Identifiers (DID). This eliminates the need for centralized login systems:

User discovery: GET /.well-known/webfinger?resource=acct:user@example.com
DID authentication: E2EE via W3C VC (Verifiable Credentials)

2. Privacy-First Design

Wander stores no user data locally. Instead, it:

Uses ephemeral WebRTC connections for P2P streaming
Implements client-side content encryption (AES-GCM)
Avoids cookies/session tokens

3. Modular Plugin Architecture

Developers can extend Wander with plugins for:

Media hosting (IPFS, Filecoin)
Blockchain integration (NFT content verification)
AI moderation (on-device LLMs like Llama.cpp)

Current Trends & Use Cases in 2024–2025

Post-Twitter Migration: Universities and startups use Wander to create federated alternatives to LinkedIn/Mastodon.
AI-Enhanced Moderation: A 2025 plugin uses Whisper for real-time audio transcription and spam detection.
Blockchain Synergy: NFT-based content licensing via Ethereum smart contracts.

Code Example: WebRTC Peer Discovery

Wander’s P2P streaming relies on WebRTC for low-latency connections:

async function discoverPeers(roomId) {
  const config = { iceServers: [{ urls: "stun://stun.laut.io:443" }] };
  const peerConnection = new RTCPeerConnection(config);
  const offer = await peerConnection.createOffer();
  await peerConnection.setLocalDescription(offer);
  // Broadcast offer via ActivityPub to room members
  return peerConnection;
}

This code snippet shows how Wander bridges P2P networking with federated protocols — a powerful combo for real-time apps.

Why Wander Matters for Web Developers

Lower barrier to entry: No need to master complex APIs
Future-proof: Built on W3C standards (ActivityPub, DID, WebRTC)
Monetization potential: Plugin marketplace for enterprise use cases

Conclusion: Join the Fediverse Revolution

Wander isn’t just a tool — it’s a gateway to a more open, privacy-respecting internet. Whether you’re building the next federated social app or exploring decentralized identity systems, Wander provides the infrastructure to thrive.

Ready to dive into the small web? Check out the Wander GitHub repo or join our #tech chat on Matrix. The future of the web is federated — are you in?

DEV Community