Home Live Demo Funding
Knuth
Home Live Demo Funding
Menu
Home Live Demo Funding
Knuth

High Performance Bitcoin Cash Development Platform

Coming 2026

# The Best BCH Wallet

A new wallet experience powered by Knuth's battle-tested C++ core. Fast transactions, modern interface, and rock-solid security.

Web & Mobile WebAssembly Powered CashTokens Ready

# Built for Bitcoin Cash Professionals

High performance Bitcoin Cash (BCH) full node implementation focused on extra capacity and throughput. More than a client — it's a complete development platform with libraries in 7 languages and an optimized executable node.

Miners & Pools

Running competitive operations at scale

Exchanges

Dependable full indexation & high throughput

Enterprises

Building production-grade applications

Developers

Taking projects to the next level

Researchers

Exploring blockchain innovation

Newcomers

First steps in the blockchain ecosystem

# Layered Architecture

All language bindings share the same high-performance C++23 core. Universal Bitcoin Cash API across all platforms.

High-Level Language Bindings
Python

Python

JavaScript

JavaScript

TypeScript

TypeScript

C#

C#

NEW
WebAssembly

WASM

Universal C Bindings
C

C Language Binding

The universal interlingua that connects all programming languages to the C++ core

High-Performance Core
C++

C++23 Core Implementation

Optimized for modern CPUs (Haswell+ baseline)

Libraries

Use Knuth as a library in your projects. Build custom Bitcoin Cash applications with full blockchain access.

Executable Node

Run the full node executable. High-performance Bitcoin Cash node ready to use out of the box.

Direct Integration

Unlike JSON-RPC, your application becomes the node. All components run as a single process with native performance—no network overhead.

Quick Start Guide

# Getting Started

Install and use Knuth in your preferred environment.

Select an option to see installation instructions and usage examples

Python Python

Coming Soon

TypeScript TypeScript

Coming Soon

C# C#

Coming Soon

C++ C++

Prerequisites:

  • Python 3 with pip
  • GCC or compatible C++ compiler with C++23 support
  • CMake

Tooling Setup:

$ pip3 install kthbuild conan --user
$ conan profile detect --force
$ conan remote add kth https://packages.kth.cash/api
$ conan config install https://github.com/k-nuth/ci-utils/raw/master/conan/config2023.zip

Project Setup:

Create conanfile.txt:

[requires]
kth/KNUTH_PKG_VERSION
[generators]
CMakeDeps
CMakeToolchain
[layout]
cmake_layout

Create CMakeLists.txt:

cmake_minimum_required(VERSION 3.23)
project(pizza CXX)
 
set(CMAKE_CXX_STANDARD 23)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
find_package(kth REQUIRED)
 
add_executable(${PROJECT_NAME} pizza.cpp)
target_link_libraries(${PROJECT_NAME} PRIVATE kth::node)

Code (pizza.cpp):

#include <atomic>
#include <csignal>
#include <print>
#include <thread>
#include <kth/node.hpp>
#include <kth/node/executor/executor.hpp>
 
using namespace kth;
 
constexpr uint64_t pizza_block = 57043; // Bitcoin Pizza Day (May 22, 2010)
 
std::atomic<bool> keep_running{true};
std::atomic<bool> block_received{false};
 
void handle_signal(int sig) {
  keep_running = false;
  std::println("\nInterrupted by signal");
}
 
int main() {
  std::signal(SIGINT, handle_signal);
  std::signal(SIGTERM, handle_signal);
 
  node::configuration config{domain::config::network::mainnet};
  node::executor exec{config, false};
 
  std::println("Initializing and starting node...");
 
  bool started = false;
  exec.init_run("", node::start_modules::all, [&](code const& ec) {
    if (ec) {
      std::println("Error starting node: {}", ec.message());
      return;
    }
    started = true;
    std::println("✓ Node running");
  });
 
  while (!started && keep_running) {
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
  }
 
  if (!started) return 1;
 
  auto& chain = exec.node().chain();
 
  // Wait for sync to pizza_block
  size_t current_height = 0;
  while (keep_running && current_height < pizza_block) {
    chain.fetch_last_height([&](code const& ec, size_t h) {
      if (!ec) current_height = h;
    });
    std::print("\r🔄 Syncing... {}/{}", current_height, pizza_block);
    std::this_thread::sleep_for(std::chrono::seconds(1));
  }
 
  if (!keep_running) {
    exec.close();
    return 0;
  }
 
  std::println("\n✓ Synced to block {}", pizza_block);
  std::println("Fetching block {} (Bitcoin Pizza Day)...", pizza_block);
 
  chain.fetch_block(pizza_block, [&](code const& ec, block_const_ptr block, size_t h) {
    if (ec) {
      std::println("Error fetching block: {}", ec.message());
      block_received = true;
      return;
    }
 
    auto hash = block->hash();
    std::print("Block {}: ", h);
    for (int i = hash.size() - 1; i >= 0; --i) {
      std::print("{:02x}", (int)hash[i]);
    }
    std::println("");
    block_received = true;
  });
 
  // Wait for block to be received or interrupted
  while (keep_running && !block_received) {
    std::this_thread::sleep_for(std::chrono::seconds(1));
  }
 
  exec.close();
  return 0;
}

Build:

$ conan install . --build=missing -s compiler.cppstd=23
$ cmake --preset conan-release
$ cmake --build --preset conan-release

Run:

$ ./build/Release/pizza

C C

Prerequisites:

  • Python 3 with pip
  • GCC or compatible C compiler with C11 support
  • CMake

Tooling Setup:

$ pip3 install kthbuild conan --user
$ conan profile detect --force
$ conan remote add kth https://packages.kth.cash/api
$ conan config install https://github.com/k-nuth/ci-utils/raw/master/conan/config2023.zip

Project Setup:

Create conanfile.txt:

[requires]
kth/KNUTH_PKG_VERSION
[generators]
CMakeDeps
CMakeToolchain
[layout]
cmake_layout

Create CMakeLists.txt:

cmake_minimum_required(VERSION 3.23)
project(pizza C CXX)
 
set(CMAKE_C_STANDARD 11)
set(CMAKE_C_STANDARD_REQUIRED ON)
 
find_package(kth REQUIRED)
 
add_executable(${PROJECT_NAME} pizza.c)
set_target_properties(${PROJECT_NAME} PROPERTIES LINKER_LANGUAGE CXX)
target_link_libraries(${PROJECT_NAME} PRIVATE kth::c-api)

Code (pizza.c):

#include <signal.h>
#include <stdatomic.h>
#include <stdio.h>
#include <unistd.h>
#include <kth/capi.h>
 
#define PIZZA_BLOCK 57043 // Bitcoin Pizza Day (May 22, 2010)
 
atomic_int keep_running = 1;
atomic_int block_received = 0;
 
void handle_signal(int sig) {
  keep_running = 0;
  printf("\nInterrupted by signal\n");
}
 
void print_block(kth_chain_t c, void* ctx, kth_error_code_t err, kth_block_t block, kth_size_t h) {
  if (err != kth_ec_success) {
    printf("Error fetching block: %d\n", err);
    block_received = 1;
    return;
  }
  kth_hash_t hash = kth_chain_block_hash(block);
  printf("Block %llu: ", (unsigned long long)h);
  for (int i = 31; i >= 0; --i) printf("%02x", hash.hash[i]);
  printf("\n");
  kth_chain_block_destruct(block);
  block_received = 1;
}
 
int main() {
  signal(SIGINT, handle_signal);
  signal(SIGTERM, handle_signal);
 
  kth_settings cfg = kth_config_settings_default(kth_network_mainnet);
  kth_node_t node = kth_node_construct(&cfg, 0);
 
  printf("Starting node...\n");
  fflush(stdout);
  if (!node || kth_node_init_run_sync(node, kth_start_modules_all) != kth_ec_success) return 1;
  printf("✓ Node running\n");
 
  kth_chain_t chain = kth_node_get_chain(node);
  uint64_t h = 0;
  kth_chain_sync_last_height(chain, &h);
 
  // Wait for sync to PIZZA_BLOCK
  while (keep_running && h < PIZZA_BLOCK) {
    printf("\r🔄 Syncing... %llu/%llu", h, (uint64_t)PIZZA_BLOCK);
    fflush(stdout);
    sleep(1);
    kth_chain_sync_last_height(chain, &h);
  }
 
  if (!keep_running) {
    kth_node_destruct(node);
    return 0;
  }
 
  printf("\n✓ Synced to block %llu\n", h);
  printf("Fetching block %llu (Bitcoin Pizza Day)...\n", (uint64_t)PIZZA_BLOCK);
  kth_chain_async_block_by_height(chain, NULL, PIZZA_BLOCK, print_block);
 
  // Wait for block to be received or interrupted
  while (keep_running && !block_received) {
    sleep(1);
  }
 
  kth_node_destruct(node);
  return 0;
}

Build:

$ conan install . --build=missing -s compiler.cppstd=23
$ cmake --preset conan-release
$ cmake --build --preset conan-release

Run:

$ ./build/Release/pizza

JavaScript JavaScript

Coming Soon

WASM WebAssembly

Prerequisites:

  • Modern browser with WebAssembly support

Try our interactive WebAssembly examples in your browser!

Try it in Your Browser

Executable Node

Prerequisites:

  • Python 3 with pip
  • GCC or compatible C++ compiler with C++23 support
  • CMake
1. Install and configure the Knuth build helper
$ pip3 install kthbuild conan --user
$ conan profile detect --force
$ conan remote add kth https://packages.kth.cash/api
$ conan config install https://github.com/k-nuth/ci-utils/raw/master/conan/config2023.zip
2. Install the node executable
$ conan install --requires=kth/KNUTH_PKG_VERSION --build=missing --update --deployer=direct_deploy -s compiler.cppstd=23
3. Run the node
$ ./direct_deploy/kth/bin/kth --init_run
Technical Excellence

# Features

Modular architecture, beautiful code, and industry-leading standards for building production-grade applications.

COMING SOON

Wallet Capabilities

Knuth libraries now include an evolved Wallet API for building production-grade wallet applications. Our WebAssembly binding enables cutting-edge web and mobile wallets with modern UI/UX — powered by the same battle-tested, high-performance C++ core.

Web Wallets Mobile Wallets WebAssembly Powered Battle-Tested C++ Core

Development Platform

Full node implementation plus development platform. Modern C++23 core with libraries in multiple languages for building custom Bitcoin Cash applications.

Cross-Platform

Works on any 64-bit architecture. Compile natively on Linux, Windows, macOS, FreeBSD, and more with zero friction. Run in the browser with WebAssembly.

Optimized Build System

Auto-detects CPU microarchitecture and creates optimized binaries. Pre-compiled binaries compatible with Intel Haswell+ architecture for maximum performance.

Database Modes

Three database modes: normal, pruned, and full-indexed for specialized use cases.

Bitcoin Cash Since 2017

One of the first implementations supporting BCH from day one. Continuously updated with every protocol upgrade: Schnorr signatures, CashTokens, ABLA, and more.

Industry Standards

Built with Abseil, Boost, GMP, ICU. Toolchain: GCC, Clang, MSVC, CMake, Conan, clang-tidy, clang-format.

Modular Architecture

Completely modular design. Each module is an independent library following single-responsibility principle. Use them together or separately. Protocol changes can be introduced faster and more efficiently.

Live Demo

# Try it in Your Browser

Experience the power of Knuth running natively in WebAssembly. No installation required!

Choose an example:

Address Converter

Output

// Output will appear here...

Loading WASM...

Please wait

Let's Connect

# Get in Touch

Join our community, follow our updates, or reach out directly. We're always happy to connect!

GitHub
GitHub
X (Twitter)
X (Twitter)
Telegram
Telegram
Email
Email

Open source, community-driven, and committed to Bitcoin Cash.

Copyright © 2016-, Knuth
'; });