A Game of Strategy and Diplomacy Running on the EVM

An unstoppable game of strategy and diplomacy running on the EVM. It allows players to collaborate through on-chain alliances while remaining sovereign. A first of its kind.

Stratagems, the infinite board game

A persistent and permission-less game where a set of colors compete for the control of the board.

Multiplayer dungeon generated & owned by the players

One of the first games fully running on the EVM. It let players explore (and generate) a dungeon to discover monsters and loot.

Template to build decentralised applications

A template to build production-ready decentralised applications with full support for IPFS. It combines the best tools out there including viem, hardhat and svelte.

Hardhat plugin for contract deployment and testing

The hardhat plugin of choice to deploy contracts on the various EVM chains. It boasts a multitude of features, including Hot Contract Replacement and safe retries.

A file-based work contract and autonomous runner for agents

Discovers, schedules, claims and runs work across many repos, as a guided human loop or an unattended autonomous runner, on top of a file-based work/ contract and an atomic git-ref claim protocol.

Delayed, condition-based transaction execution

A service to schedule the execution of encrypted transactions in the future, revealed only when the time comes.

The Bleeps DAO and Its Fully Onchain Sounds

The first composable sounds fully generated on-chain with zero externalities: no backend, no ipfs, no client-code, and a melody minter where some of the proceeds go to the Bleeps DAO and its members.

On-chain Generative Bitmaps With Zero Externalities

The first on-chain generative art project to make full use of tokenURI to remove all external dependencies. It generates SVG and Bitmap from the smart contract directly.

Game Studio Building Unstoppable Games

One of the oldest game studios in the blockchain gaming space. It created the first game playable with Metamask back in 2016.

A Market For Random NFTs

The first of its kind. Mystery Market allowed anyone to randomize their NFTs and sell them on a fully decentralised marketplace.

On Chain Card Game For Loot

A battle game for Loot. Each Loot token represents a set of cards that you have to strategically play to win.

A simultaneous turn-based game of mayhem

A simultaneous turn-based game of mayhem, persistent and permissionless. Players act at the same time in each turn, creating a fast, chaotic and strategic on-chain game.

Embed Your Art Anywhere

Platforms like twitter and facebook use meta tags to display previews when sharing a url. Embed.art gives you an easy way to share your token visuals on such platforms without running your own preview generator.

A fully decentralised dungeon game

A fully decentralised dungeon crawler where players enter at their own risk. Built as a fully on-chain, decentralised app and game, with pixel art by VEXED.

A hidden-information duel secured by ZK proofs

A game where two players outwit each other to bring about their opponent's downfall while staying hidden. It uses Zero Knowledge Proofs to let the game run fairly on an open blockchain.

Prediction-market based curation using off-chain betting

A prediction-market based curation system using off-chain betting. A decentralised discussion platform is implemented as a demo, but is just one of many use cases.

Multi-session remote control for the pi coding agent

A modern, multi-session remote control platform for the pi coding agent: a standalone server, a web dashboard, and a CLI bridge extension. Manage many pi sessions concurrently across your workspace directories from the browser while your terminal CLI stays synced in real time.

A framework-agnostic smart contract deployment system for Ethereum

A framework-agnostic deployment system for Ethereum-compatible networks: write deploy scripts once and run them anywhere (including in the browser), with deterministic CREATE2 / CREATE3 deployments and no lock-in to a single dev toolchain.

A lightweight, modular Ethereum event indexer that runs anywhere

A lightweight, modular Ethereum event indexer that runs anywhere JavaScript does (browser, node, or workers). You supply a processor that folds contract events into state and a store to persist it, and it handles the fetch/reorg/replay loop, so an app can index directly on the client with no backend.

An agent-first toolchain for PICO-8 game development

An agent-first toolchain that makes PICO-8 game development easy with an LLM, built on the incur CLI framework: text-based tools for sprites, SFX/music, running, playtesting and exporting a cart, all designed to be driven by a coding agent.

Self-host a static site on IPFS across your own nodes

Self-host a static website on IPFS across one or more self-owned Kubo nodes, without a paid pinning service. pinnace provisions the nodes, deploys your site as a content-addressed archive pinned on every node with the same CID, manages mutable ipns:// names with key-derived per-site keys and publisher/replica failover, keeps gateway caches warm, and emits CI steps. It is both a CLI and a TypeScript library.

Deploy parametrized clone contracts with immutable arguments

Creates clone contracts whose immutable arguments are stored in the code region of the proxy and appended to the delegatecall calldata on every call, so the implementation reads them straight from calldata. Cheaper to deploy and to run than EIP-1167 (no storage writes/loads), since the parameters live in code, not storage.

Blockies generated on-chain in Solidity

Blockies (the Ethereum identicon pattern) generated entirely on-chain in Solidity, so every Ethereum wallet automatically owns its own blocky as an NFT with no external metadata or image service.

Give one Unix account a leak-proof internet connection

Forces everything a Unix account does (a shell, any tool, an editor, a script) through an anonymizer like Tor, enforced by the Linux kernel, fail-closed: if the anonymizer is down, that account's traffic is dropped, never sent in the clear. Ships a verify command that PROVES the account is anonymized instead of asking you to trust it.

Run any containerized tool with its egress forced through a proxy, fail-closed

Wraps a container image and command so ALL of its TCP and DNS egress is forced through a SOCKS5h proxy by the network layer (not the tool's own proxy awareness), fail-closed: if the proxy is unreachable, traffic is dropped, never sent to the host network. Ships a verify leak-test that proves no traffic escapes the proxy.

Seed a tool config into an anonymized identity

A Go CLI that seeds the configuration a local-service-using tool needs into an anonymized identity, and declares the one direct-egress IP exception that tool requires (e.g. a LAN/loopback model server), so the tool is ready to run anonymized. It is a config seeder, not an account provisioner or a runtime launcher. Part of the anonctl / netcage family.

Let your AI agent drive a real, logged-in browser on your own machine

A small CLI (and MCP server) that gives an agent hands on a real Chromium browser. It reuses a browser YOU logged into yourself, on your machine and your IP, so the agent can read and act on the web apps you already use, via composable page verbs (goto, snapshot, click, type, eval, script, wait).

Distill HTML into clean, token-efficient markdown for agents

Turns HTML into clean, token-efficient markdown for AI agents. The main entry point is pure and local: you hand it HTML you already have and it returns markdown, with no network I/O by default and adjustable output sizes.

A modular AI-driven CAPTCHA solver toolkit

A modular, AI-driven toolkit that solves CAPTCHAs through a shared perceive / plan / act loop with pluggable solver brains and interchangeable front-ends (a browser extension and a Playwright driver). It is also designed to serve as the hands for webhands, letting an agent act on a real browser to get past a challenge.

Interactively link AI skills into a target directory via symlinks

A CLI that recursively discovers AI skills (any directory containing a SKILL.md) under a source root, then lets you interactively toggle which ones are symlinked into a target directory (default ~/.agents/skills), grouped by their folder hierarchy.

A minimal logging facade for libraries

A tiny, zero-cost logging facade a library can depend on without imposing a logger on its users: the library logs through named-logs, and the host app decides at runtime whether (and how) those logs are shown by plugging in an implementation like named-logs-console.

A console implementation of the named-logs facade

The console-backed implementation of the named-logs facade: it routes every log call to the browser/node console while preserving the original file and line, and supports per-namespace filtering (like debug) and log levels, so an app gets full control over library logging.

Load .env files by mode and run a command with them set

Both a CLI and an importable module: it loads your .env / .env.local (and mode-specific) files and runs a command with that environment set, and can even resolve variable references directly inside the command line itself.

A local dev server that emulates IPFS gateway behavior

A local static server (built on lws / local-web-server) that emulates how an IPFS gateway serves a site: trailing-slash redirects and /ipfs/<hash> URLs, so you can test an IPFS-bound build locally before you pin it and be confident the paths resolve.

Generate an optimized set of favicons and a PWA web manifest

A CLI that generates an optimized, deliberately small set of favicons and a web manifest from a single input image and a config file, following modern favicon best practice, and can optionally inject the matching PWA meta tags into your HTML.

Copy checked-in default files to their real, git-ignored names

A small helper that copies committed default files (e.g. a `foo.default.json`) to their actual, usually git-ignored, filename (`foo.json`), so a fresh checkout gets working local config in one step.

Watch files and run a command as soon as they change

A lightweight file watcher that runs a command as soon as watched files or directories change, with debounced execution, support for watching files that do not exist yet, and automatic re-subscription when a watched directory is deleted and recreated. Handy for rebuild/test/restart dev loops.

Run external programs from Forge over a 2-way channel

Lets a Foundry (forge) script execute an external program and talk to it over an open two-way communication channel, so a Solidity test or deploy script can drive and exchange data with tooling outside the EVM.

Base Solidity contracts and utilities

A set of reusable base Solidity contracts and utilities: ERC20 (with ERC2612 permit), ERC721 (with ERC4494 and on-chain tokenURI helpers), ERC165 and ERC173 building blocks, plus utilities like Multicall and a Guardian, ready to build production token contracts on.

Upgradeable proxy contracts, including an immutable router

A collection of Solidity proxy patterns for upgradeable contracts: ERC1967 storage, ERC173 ownership, a Diamond (multi-facet) implementation, and an immutable router that dispatches calls to fixed implementations without a mutable storage slot.

A subgraph for indexing EIP-721 NFTs

A subgraph for The Graph that indexes EIP-721 (NFT) transfers and ownership, deployable to your own graph-node so an app can query NFT activity without running a full indexer.

A unified TypeScript interface for batch-based remote SQL

A type-safe TypeScript interface that abstracts remote SQL databases which only support batch transactions, with prepared statements and parameter binding and ready-made backends for Cloudflare D1 and LibSQL behind one common API.

Type-safe JSON-RPC clients with optional rate-limiting

A TypeScript library for building JSON-RPC clients with full type safety (pass a method map and every call is typed), plus error handling and optional rate-limiting, offered as both a curried and a proxied API.

Build syncable, local-first stores with CRDT conflict resolution

A TypeScript library for building local-first stores: data lives locally and syncs to a server when available, with last-writer-wins CRDT merges, multi-account switching, a type-safe schema, and pluggable storage. Works as a Svelte store out of the box.

A local mempool proxy to intercept and hold Ethereum transactions

An RPC proxy that sits between your app and an Ethereum node: it intercepts `eth_sendRawTransaction`, holds transactions in a local mempool, and gives you full control (including gas-price filtering) over when and how they are forwarded upstream. Ideal for debugging and testing mempool behavior.

A minimal, type-safe event emitter for TypeScript

A tiny, tree-shakeable, zero-dependency event emitter for TypeScript with fully typed event maps and listeners and a simple `on` / `off` / `once` / `emit` API. The event-emission core behind observator.

Track Ethereum transactions through their lifecycle, reactively

A lightweight TypeScript library that tracks Ethereum transactions across their whole lifecycle (pending, mined, confirmed, dropped) and emits reactive updates as their status changes. It is the tx-observer package of the etherkit collection, replacing the standalone ethereum-tx-observer.

Anonymous-capable, self-hosted, account-free web search and fetch for agents

Anonymous-capable, self-hosted, account-free web search and fetch for agents. CLI + MCP (built on incur), pi-agnostic. Swappable backend and egress (direct, http proxy, socks5/Tor).

TypeScript types for the EIP-1193 Ethereum provider

A dependency-free set of TypeScript type definitions for the EIP-1193 Ethereum provider interface (the request/event contract every wallet and dapp speaks), so your code can talk to any injected provider with full type safety.

A messaging system for Ethereum accounts

Lets Ethereum accounts send each other encrypted messages, stored by a backend (Bun or Cloudflare Workers) and retrieved by clients, with real-time delivery over WebSockets. When a recipient has no public key on record yet, the sender can reach them with a clear-text introduction to make first contact.

A type-safe observable store that emits JSON Patch on each change

A type-safe observable store that emits an event for each top-level field change, with the callback receiving a JSON Patch (RFC 6902) array. Supports fine-grained keyed and value-based subscriptions and id-based array tracking. Built on patch-recorder and radiate.

Record JSON Patch from mutations via a proxy

Wraps objects, arrays, Maps and Sets in a proxy and records every mutation as a JSON Patch (RFC 6902) array as it happens. It mutates in place (original reference kept, no copying), so you get accurate, immediate patches with zero memory overhead and full type safety. The mutation-recording core behind observator.

Universal signals: a facade over any signal library

A framework-agnostic, zero-dependency facade over any signal library's reactive primitives (reactive, signal, effect), with pluggable adapters for Svelte 5 and Solid.js so libraries can stay reactivity-agnostic.

Pin a Zod schema to your canonical TypeScript types by exact identity

A tiny, zero-dependency Zod 4 helper that forces, at compile time, a schema's input and output types to be EXACTLY your hand-written canonical types (not just assignable), so it catches extra keys and narrowed values the usual annotation lets through. Transform-aware and zero runtime cost.

A from-scratch web browser in Rust for a post-trusted-server web

A from-scratch, general-purpose web browser written in Rust for a "post-trusted-server" web: native ipfs:// resolution, a native Ethereum (EIP-1193) provider with ENS-name resolution, privacy-protecting and local-first, while staying fully compatible with the normal server web. Ships headless resolve/version subcommands so an ENS-to-CID resolution can be scripted over ssh.

A test suite for Ethereum contracts

A reusable test suite for Ethereum smart contracts, providing assertions and helpers to exercise contract behavior across scenarios so a project can ship a thorough, shared test harness rather than rewriting one each time.

A slim, in-browser EIP-1193 Ethereum node

A slim, execution-only in-browser EIP-1193 Ethereum node built on @ethereumjs/vm. It sits between bare EVM.runCall (too low-level: no blocks/receipts/logs) and a full in-browser node (heavy): it runs real transactions with a minimal mock block/receipt/log layer, exposing a standard provider so an app or test can use a real EVM without a backend.

revm compiled to WebAssembly, with a typed JS API

An unofficial binding that compiles revm (bluealloy, MIT) to WebAssembly with a typed JavaScript API, so you can run a real EVM in a browser (or any JS runtime) with no Rust toolchain. The EVM is revm's; this package is the build config, host interface and decoder.

An Ethereum CLI and MCP server

A comprehensive Ethereum toolkit usable as a CLI (ecli) or as an MCP server for AI assistants, covering reading chain data, sending transactions and interacting with smart contracts. One binary, two interfaces: the same operations from the terminal or from an agent.

An enhanced zx with markdown preprocessing for shell scripts

An enhanced version of zx that fixes markdown parsing annoyances (indentation, code fences) so you can write shell scripts as markdown, plus quality-of-life features that smooth over the common rough edges when scripting with zx.

A configurable EVM faucet server

A configurable EVM faucet server that dispenses testnet/devnet tokens with optional Prosopo captcha protection. Supports multiple chains and runs on Cloudflare Workers or Node.js.

A production-ready Ethereum smart contract dev template

A production-ready template for developing EVM smart contracts with Hardhat v3 and hardhat-deploy v2 plus the rocketh deployment system. It pairs a flexible, script-based deploy system with sensible defaults so a new contract project starts ready to build, test and deploy.

Wallet connection with session accounts and social login

A modern wallet connection library with seamless authentication via session accounts. It supports both social login (email, OAuth, mnemonic) and traditional Web3 wallet connections, and keeps session accounts that persist across device and browser sessions.

A self-hostable Web Push notification server

A self-hostable push notification server that delivers Web Push notifications to subscribed browsers, so an app can send real-time updates without depending on a third-party push service.

Generate React hooks from Svelte-like stores

A small, zero-dependency utility (only a peer dep on React) that turns any observable following the Svelte store contract into a React hook, so a shared store can be consumed in both Svelte and React apps.

Expand env vars in a command line, then run it, cross-platform

Expands environment variables in a command line, then runs it, identically on every platform. It fixes the npm-scripts footgun where $npm_package_name is expanded by sh on Unix but passed through literally by cmd.exe on Windows, so a script that works on one OS breaks on the other.

Replace a name across a folder: files, dirs and contents

A CLI that recursively renames files and directories and replaces a name inside text file contents, so a rename or rebrand propagates everywhere in a project in one pass.

Always working on new stuff

This is only a selection. Browse every repository, including the experiments and works in progress, on GitHub.