Code orchestration for web3.

Deploy modular adapters. Own your code.

Building web3 apps today means starting from scratch every time.

You spend 40-60% of your time on boilerplate:

• Setting up wallet connections (RainbowKit, SIWE, session management)
• Configuring indexers (Ponder, The Graph, custom event listeners)
• Managing RPC providers (Alchemy, Infura, fallbacks)
• Handling multi-chain logic (contract addresses, chain routing)
• Generating types from ABIs and schemas

And when you want to switch providers—you refactor everything.

Kompo eliminates the boilerplate while keeping you 100% in control.

A code orchestration framework for TypeScript web3 developers.

Built on Hexagonal Architecture (Ports & Adapters), Kompo lets you:

• Declare your stack once in a single config file.
• Deploy modular adapters directly into your codebase.
• Swap providers anytime without refactoring.

The Terraform of web3 code. Declare once, swap providers anytime.

Think: Terraform for your application code, not your infrastructure.

Infrastructure as Code democratized cloud deployment. Code as a Service democratizes web3 development.

pnpm create kompo@latest my-awesome-app
cd my-awesome-app

? Select authentication strategy
  → Wallet + session (SIWE + NextAuth)

? Select indexing provider
  → Ponder

? Select chains
  → Ethereum
  → Polygon
  → Arbitrum

✓ Stack configured! 5 adapters installed.
✓ Types generated from ABIs.
✓ Ready to build.

pnpm dev

• ✅ Typed multi-chain wallet connection
• ✅ Smart contract indexing configured
• ✅ RPC provider setup with fallbacks
• ✅ Production patterns included
• ✅ Ready to ship

Hexagonal Architecture separates business logic from infrastructure concerns:

┌─────────────────────────────────────┐
│    Your Core Logic (Pure TS)        │
│  (business rules, no dependencies)  │
└──────────────┬──────────────────────┘
               │
┌──────────────┴──────────────────────┐
│  Ports (Interfaces / Contracts)     │
│  (what your core needs)             │
└──────────────┬──────────────────────┘
               │
┌──────────────┴──────────────────────┐
│  Adapters (Implementations)         │
│  (how you get it: Alchemy, Ponder)  │
└─────────────────────────────────────┘

Change an adapter (e.g., Alchemy → Infura) → everything else works unchanged.

Before (3+ hours of refactoring):

// Old code using Alchemy
import { Alchemy, Network } from "alchemy-sdk";
const alchemy = new Alchemy({ apiKey: process.env.ALCHEMY_KEY });
const balance = await alchemy.core.getBalance(address);

After (1 line of config):

// kompo.config.json
{
  "adapters": {
    "rpc-provider": {
      "port": "rpc",
      "engine": "infura"
    }
  }
}

// Your code stays the same
import { rpc } from "@/composition";
const balance = await rpc.getBalance(address);

pnpm kompo add template nft-marketplace

Pre-built: Wallet connection, Contract interaction (mint, list, buy), Multi-chain contract management, Event indexing.

pnpm kompo add template dao

Pre-built: Member voting, Proposal execution, Cross-chain quorum, Treasury management.

pnpm kompo add template defi-dashboard

Pre-built: Token balance aggregation, Swap routing, Staking positions, Cross-chain liquidity.

• Pre-configured adapters for wallet auth, indexing, RPC.
• Multi-chain setup in one file (kompo.config.json).
• CLI scaffolds production patterns in seconds.

• Change RPC providers with 1 line of config.
• Swap indexers without touching your code.
• Add new chains to existing contracts instantly.
• Own 100% of your codebase (it's all in your repo).

• TypeScript types generated from smart contract ABIs.
• Full autocomplete for contract methods and events.
• Compile-time validation prevents runtime errors.

• Error handling and retry logic included.
• RPC rate limiting and caching built-in.
• Server-side signing patterns.
• OpenTelemetry integration for monitoring.

• Framework: Next.js (extensible to Remix, NestJS, Express)
• Runtime: TypeScript + Node.js
• CLI: Powerful generator for scaffolding and code generation
• Architecture: Hexagonal (Ports & Adapters)
• Web3 Libraries: Viem, RainbowKit, Ponder, Alchemy SDK

Kompo is currently in Beta (v0.1.0).

• ✅ Fully functional and used in production
• ✅ APIs stable and well-documented
• 🔄 Adding new adapters and templates regularly
• ⚠️ Expect occasional breaking changes as we move toward v1.0

pnpm create kompo@latest my-app
cd my-app

# Example: Add a Ponder Indexer
pnpm kompo add port indexer --domain blockchain
pnpm kompo add adapter ponder --port indexer --domain blockchain

# Generates the composition layer
pnpm kompo wire blockchain --app my-app

Kompo uses a central JSON configuration file (libs/config/kompo.config.json) to manage your architecture.

{
  "project": {
    "name": "my-app",
    "org": "acme"
  },
  "domains": {
    "blockchain": {
      "ports": ["indexer"]
    }
  },
  "adapters": {
    "indexer-ponder": {
      "port": "indexer",
      "engine": "ponder",
      "path": "libs/adapters/indexer-ponder"
    }
  },
  "apps": {
    "apps/my-app": {
      "ports": {
        "indexer": "indexer-ponder"
      }
    }
  }
}

Once wired, Kompo generates a type-safe composition layer. You simply import the domain.

// src/app/page.tsx
// Import the wired domain from the composition layer
import { blockchain } from '@/composition';

export default async function Dashboard() {
  // Access your adapters through the domain interface
  const updates = await blockchain.indexer.getLatestUpdates();

  return (
    <div>
      {updates.map(u => <div key={u.id}>{u.hash}</div>)}
    </div>
  );
}

• QuickNode and Ankr RPC adapters
• DAO governance template
• Enhanced error handling and logging
• Security best practices guide

• Subgraph integration improvements
• Cross-chain transaction orchestration helpers
• Architecture review credits system

• AI-assisted code generation
• VSCode extension for adapter management
• Kompo Cloud for team configuration sharing

We welcome contributions from the community!

1. Fork the repo: git clone https://github.com/kompo-dev/kompo.git
2. Install dependencies: pnpm install
3. Create a feature branch: git checkout -b feature/my-feature
4. Submit a pull request.

Check out CONTRIBUTING.md for detailed guidelines.

• 💬 Discord Community - Real-time chat and support
• 🐦 Twitter - Latest updates and announcements
• 💌 Email Updates - Subscribe for major releases

MIT © 2026 SmarttDev and Kompo contributors