Building a Bitcoin GUI with Rust and Tauri: A Proof of Concept

Introduction

Bitcoin core is the pillar of the Bitcoin network. It provides critical functionalities such as transaction validation, blockchain synchronisation, and wallet management.

Traditionally, Bitcoin core's architecture is monolithic: That is it packs the bitcoin-node, bitcoin-gui and bitcoin-wallet all in a single executable. But recently, there have been works that introduced a multiprocess architecture that allows for better modularity and flexibility.

In this proof of concept (PoC), I set out to build a standalone GUI using Rust and Tauri (Rust GUI framework) that communicates with the Bitcoin Core via Inter-Process Communication (IPC). The goal of this project is to explore how Bitcoin's new multiprocess architecture enables external applications to interact with it's core components without being tightly coupled to the original GUI.

This article walks through this Proof of Concept, what is being done and why it is being done the way it was done. By the end, you'll have a deeper understanding of:

• Bitcoin Core's multiprocess architecture and its advantages.

• Using IPC to communicate between the GUI and Bitcoin Core processes.

Understanding Bitcoin Core Multiprocess

Bitcoin Core's multiprocess architecture introduces a separation of concerns between different components, making it more modular and scalable. The core components includes:

• bitcoin-node: This component handles the Bitcoin blockchain, network communication, and consensus mechanisms.

• bitcoin-wallet: This component manages wallets and transactions separately from the main node.

• bitcoin-gui: The traditional graphical interface that interacts with the node and wallet.

In this POC, the GUI operates as an independent binary that communicates with Bitcoin Core via IPC, instead of being bundled with the core application. This allows for greater flexibility and opens up possibilities for custom Bitcoin applications without modifying the core Bitcoin repository.

High-Level Overview of Inter-Process Communication (IPC) using Cap'n Proto

Inter-Process Communication (IPC) is the mechanism that enables different processes running on the same or separate machines to exchange data. In the context of Bitcoin Core's multiprocess architecture, IPC allows components like bitcoin-node, bitcoin-wallet, and bitcoin-gui to communicate efficiently without being part of a single monolithic application.

Bitcoin Core's multiprocess architecture leverages Cap'n Proto, a high-performance, schema-based IPC framework, to facilitate communication between these components.

What is Cap'n Proto?

Cap'n Proto is a serialization format and RPC (Remote Procedure Call) framework designed for high efficiency. Unlike the traditional serialization formats like JSON or Protocol Buffers.

So Bitcoin Core uses Cap'n Proto as the communication layer between its various components, allowing for seamless and efficient interaction.

How IPC Works in Bitcoin Core Using Cap'n Proto

1. Processes communicate over an IPC transport layer

• bitcoin-node acts as the core service, managing the blockchain and P2P network.

• bitcoin-wallet and bitcoin-gui communicate with bitcoin-node via socket-based IPC (e.g., UNIX domain sockets)

2. Message structure is defined using Cap'n Proto schemas

• These schemas define how requests and responses should be structured.

• For example, a request to fetch the current block height would be structured in Cap'n Proto format

3. Cap'n Proto RPC framework enables asynchronous communication

• Requests and responses are handled in a non-blocking manner.

• This ensures that multiple components can communicate efficiently without introducing performance bottlenecks.

4. Secure and lightweight communication

• Cap'n Proto enables lightweight and memory-efficient communication, reducing latency.

• Since messages are directly mapped to memory, there's minimal processing overhead.

Example: Fetching Blockchain Information via IPC

Let's assume we want to get the current block height from bitcoin-node, using our bitcoin-gui. The process would go like this:

1. bitcoin-gui sends a request over IPC to bitcoin-node, structured using Cap'n Proto.

2. bitcoin-node processes the request, retrieves the current block height, and encodes the responses in Cap'n Proto format.

3. The response is sent back over IPC to bitcoin-gui.

4. bitcoin-gui reads and displays the information without additional serialization/deserialization steps.

Why Cap'n Proto for Bitcoin Core?

• Performance: It is significantly faster than traditional IPC mechanisms like JSON-RPC.

• Efficiency: Reduces CPU and memory overhead by enabling zero-copy reads.

• Flexibility: Supports a complex data structures with minimal performance trade-offs.

• Security: Provides a safe and efficient way to handle inter-process communication.

By using Cap'n Proto, Bitcoin Core's multiprocess architecture ensures that different components can communicate efficiently while remaining independent, paving the way for scalable Bitcoin applications.

Building the GUI with Rust and Tauri

For the GUI, I chose Tauri due to its robust documentation and ease of use. As this was my first time building a GUI, I wanted a framework that provided a smooth learning curve while leveraging my existing web development skills. Tauri, a Rust-based GUI framework, allows developers to use familiar frontend technologies such as ReactJS, VueJS, HTML, CSS, and TailwindCSS to build the UI while using Rust for backend logic and functionality.

The setup process was straightforward, thanks to Tauri's well-structured documentation. Within a short time, I was able to initialize my project and begin development. By combining Tauri with ReactJS and TypeScript, I created an intuitive interface while ensuring efficient communication with Bitcoin Core using Rust for backend operations.

How the Frontend/UI Communicates with Bitcoin Core via IPC

The frontend, built with ReactJS and TypeScript, provides a user-friendly interface with buttons for invoking actions and forms for collecting input parameters when needed. Beneath this UI, the backend is entirely written in Rust, responsible for processing these requests and interacting with Bitcoin Core.

The communication process is structured as follows:

1. User Interaction:

• When a button in the frontend is clicked, it triggers a function that sends a request to the Rust backend.

2. Backend Invocation:

• The Rust function processes the request and initiates a connection to the Chain Interface through the socket_path where bitcoin-node is running.

3. IPC Communication via Cap’n Proto:

• The request is structured using a Cap’n Proto schema and sent through IPC to the bitcoin-node.
• bitcoin-node processes the request and generates a response.
• The response is sent back, structured again using the Cap’n Proto schema.

4. Frontend Update:

• The Rust backend receives the response and forwards it to the frontend function that originally triggered the request, updating the UI accordingly.

This architecture ensures a seamless and efficient communication pipeline, making it possible to interact with Bitcoin Core while maintaining a clean separation of concerns between the frontend and backend.

Challenges and Next Steps

Challenges Faced

Before starting this project, I aimed to compile Bitcoin Core with multiprocess support by following the documentation provided by ryanofsky, who has been leading Bitcoin’s multiprocess development. Despite my efforts, I faced persistent issues and errors, which set me back nearly two weeks. However, I didn’t let this stop my progress. Instead, I shifted focus to building the UI while initially using standard JSON-RPC to ensure responsiveness.

In the third week, I reached out for help, and Jonas from Chaincode Labs provided valuable documentation on working with Cap’n Proto. At that time, I was still using JSON-RPC instead of IPC, as required for Bitcoin’s multiprocess model. After explaining my challenges, Jonas guided me toward the correct implementation, which was a game-changer.

Additionally, Pseudorandom played a crucial role in helping me compile Bitcoin Core properly with multiprocess support. Initially, I managed to build bitcoin-node, but each time I attempted to run it, it defaulted to RPC instead of IPC. Pseudorandom's guidance helped me overcome this issue. His work on blocktalk, a Rust library for communicating with bitcoin-node via multiprocess IPC, also provided inspiration. At the time of writing, blocktalk is itself a proof-of-concept (PoC).

By the third week, I restarted the development of bitcoin-gui to fully align with Bitcoin’s multiprocess model. I successfully implemented blockchain-related functions such as:

• get_tip_height (fetches the latest block height)

• get_tip_hash (retrieves the latest block hash)

• get_hash_by_height (fetches a block hash at a given height)

• get_block_by_height (retrieves full block data by height)

Next Steps and Future Improvements

While the foundation of this project is in place, there is still much to be done:

• Expanding the functionality to include wallet interactions (e.g., bitcoin-wallet support).

• Enhancing the UI with real-time data visualization.

• Refining IPC security and error handling to improve robustness.

• Continuing to optimize performance and ensure compatibility with future Bitcoin Core multiprocess developments.

For those interested, I highly recommend checking out these resources:

• Pseudorandom blocktalk (Rust-based IPC for Bitcoin Core): GitHub Repository

• ryanofsky’s Bitcoin Multiprocess Documentation: Read Here

Conclusion

This POC shows how Bitcoin Core's multiprocess architecture enables external GUI applications to interact with its core functionalities. And by leveraging Rust and Tauri, we achieve a modular, performant, and secure Bitcoin GUI.

If you are interested in this POC, you can check out the GitHub repository.