Eclair

What Is Eclair?

Eclair (French for "lightning") is an open-source Lightning Network implementation written in Scala and running on the Java Virtual Machine (JVM). Developed by ACINQ, a Paris-based Bitcoin technology company, Eclair implements the full Lightning Network specification and is licensed under Apache 2.0.

While LND dominates in total node count and Core Lightning leads in plugin extensibility, Eclair occupies a distinct niche: high-performance routing infrastructure. ACINQ operates one of the largest Lightning nodes on the network using Eclair, managing tens of thousands of channels and hundreds of BTC in capacity. This "eat your own dog food" approach means Eclair is continuously battle-tested at scale.

Beyond the server node, ACINQ also maintains lightning-kmp, a separate Kotlin Multiplatform Lightning library derived from years of Eclair development. Lightning-kmp powers the Phoenix mobile wallet, giving ACINQ a full-stack presence from enterprise routing to consumer wallets.

How It Works

Eclair's architecture is built on the Akka actor framework, a concurrency model inspired by Erlang. Each peer connection, each Lightning channel, and each payment attempt runs as an independent actor. This design provides fault isolation (a crash in one channel does not affect others), efficient CPU utilization, and simplified testing.

Actor-Based Architecture

The actor model maps naturally to Lightning's requirements. Channels are long-lived stateful objects, while payment attempts are short-lived and ephemeral. Eclair assigns each to its own actor:

• Switchboard: manages peer connections and creates Peer actors on demand
• Peer: handles Bolt 1 messaging and spawns Channel actors for each open channel
• Channel: manages the full channel state machine per Bolt 2
• Router: maintains the network graph and computes payment paths per Bolt 7
• Relayer: coordinates HTLC forwarding across channels

Module Structure

Eclair is organized into three top-level modules:

• eclair-core: the core Lightning protocol library containing all channel logic, routing, and payment handling
• eclair-node: a server daemon that exposes a JSON API and WebSocket endpoints for application integration
• eclair-front: a stateless front-end server for cluster deployments that handles CPU-intensive gossip processing

Cluster Mode

Eclair's most distinctive feature is its cluster mode, which separates a single logical Lightning node across multiple physical servers. Front servers handle peer connections and gossip synchronization (Bolt 1 and Bolt 7), while the backend server focuses on channel management and payment processing (Bolt 2). Front servers are stateless and can be stopped or restarted without disrupting channels.

This architecture enables horizontal scaling to handle hundreds of thousands of channels: a capability that no other Lightning implementation offers natively. For enterprises running large Lightning Service Providers, cluster mode is a significant operational advantage.

Running Eclair

Eclair requires a fully synchronized Bitcoin Core node (version 30.x or higher) with SegWit support, ZeroMQ enabled, transaction indexing, and a wallet. A basic configuration looks like:

# eclair.conf
eclair.chain = mainnet
eclair.node-alias = "my-eclair-node"
eclair.server.port = 9735

# Bitcoin Core connection
eclair.bitcoind.rpcuser = "user"
eclair.bitcoind.rpcpassword = "password"
eclair.bitcoind.zmqblock = "tcp://127.0.0.1:29000"
eclair.bitcoind.zmqtx = "tcp://127.0.0.1:29001"

# Channel defaults
eclair.channel.min-funding-satoshis = 100000
eclair.router.channel-exclude-duration = 60 seconds

Eclair exposes a JSON API for managing channels, sending payments, and monitoring node state:

# Get node info
curl -u :password http://localhost:8080/getinfo

# Open a channel
curl -u :password http://localhost:8080/open \
  -d nodeId=<target_node_id> \
  -d fundingSatoshis=500000

# Send a payment
curl -u :password http://localhost:8080/payinvoice \
  -d invoice=lnbc50n1...

ACINQ's Protocol Contributions

ACINQ, primarily through developer Bastien Teinturier (t-bast), has authored or co-authored several major additions to the Lightning specification. These contributions benefit the entire Lightning ecosystem, not just Eclair users.

Trampoline Routing

Trampoline routing allows lightweight clients (particularly mobile wallets) to outsource pathfinding to better-connected nodes. The sender constructs a layered onion that routes through designated "trampoline nodes," which compute the detailed route segments between themselves. This preserves payment privacy while eliminating the need for mobile devices to download and process the full network graph.

Splicing

Splicing allows adding or removing funds from an existing channel without closing it. ACINQ drove the splicing specification and implemented full support in Eclair v0.14.0, including splice-in (adding funds), splice-out (withdrawing funds), and RBF fee bumping for splice transactions on public channels. Splicing eliminates the disruptive cycle of closing and reopening channels to adjust channel capacity.

Dual-Funding and Liquidity Ads

Dual-funding enables both parties to contribute funds when opening a channel through an interactive transaction construction protocol. Building on this, ACINQ proposed liquidity ads: a trustless, decentralized mechanism where nodes advertise available inbound liquidity at specified rates. Together with on-the-fly funding (negotiating liquidity purchases when receiving payments), these features create a more dynamic and efficient liquidity market.

Bolt 12 Offers

Eclair includes full support for Bolt 12 offers, the reusable, static invoice format that improves on traditional Bolt 11 invoices. Bolt 12 enables features like recurring payments and payer/payee privacy through blinded paths.

Phoenix Wallet and lightning-kmp

Phoenix is ACINQ's self-custodial Bitcoin wallet for iOS and Android. While Eclair targets server-side routing, Phoenix uses lightning-kmp: a separate Kotlin Multiplatform Lightning library optimized for mobile wallets. Lightning-kmp inherits architectural lessons from Eclair but is purpose-built for a different use case: sending and receiving payments rather than relaying them.

The mobile wallet architecture consists of three layers: lightning-kmp handles all Lightning and Bitcoin protocol logic, phoenix-shared contains business logic in Kotlin shared between platforms, and platform-specific UI code (Jetpack Compose on Android, SwiftUI on iOS) provides the user interface.

Phoenix leverages several ACINQ-driven features to deliver a seamless experience. Trampoline routing eliminates the need to sync the network graph on mobile. Splicing and on-the-fly funding allow channels to resize automatically when receiving payments, removing manual channel management from the user experience. Phoenix channels now use taproot by default, making them approximately 15% cheaper and indistinguishable from regular on-chain transactions.

Use Cases

High-Volume Routing Nodes

Eclair's cluster mode makes it the natural choice for operators running large routing nodes. The ability to separate gossip processing from channel management across multiple servers enables handling tens of thousands of channels simultaneously. Operators earning routing fees at scale benefit from Eclair's proven reliability under heavy load.

Lightning Service Providers

Businesses offering Lightning-as-a-service (custodial wallets, payment processing, LSP infrastructure) need enterprise-grade reliability. Eclair's architecture supports deploying inside secure enclaves: ACINQ secures their own node using AWS Nitro Enclaves combined with Ledger hardware for signing, running Eclair unmodified inside the isolated compute environment.

Mobile Wallet Infrastructure

Through lightning-kmp, ACINQ's technology powers self-custodial mobile wallets that abstract away channel management complexity. The combination of trampoline routing, automated splicing, and on-the-fly funding creates a user experience where Lightning channels are invisible to the end user: they simply send and receive Bitcoin.

Eclair vs. Other Implementations

Each major Lightning implementation serves different strengths. Understanding the tradeoffs helps operators and developers choose the right tool for their needs.

For a deeper comparison of Lightning node options, see the node implementation comparison research article.

Risks and Considerations

Smaller Ecosystem

Eclair has a smaller community and fewer third-party tools compared to LND. Most Lightning developer tutorials, libraries, and integrations target LND's gRPC API first. Developers building on Eclair may find fewer off-the-shelf solutions and community resources.

JVM Resource Requirements

Running on the JVM means Eclair has higher baseline memory consumption than C-based Core Lightning. For small-scale deployments on resource-constrained hardware (Raspberry Pi, low-end VPS), this overhead matters. The JVM advantage in developer productivity and fault tolerance comes at a cost in resource efficiency for smaller operators.

Operational Complexity

Eclair's power features (cluster mode, advanced splicing, liquidity ads) add operational complexity. The dependency on a fully synchronized, non-pruned Bitcoin Core node with specific configuration requirements creates a larger infrastructure footprint than some alternatives. For hobbyist node runners, simpler implementations may be more appropriate.

Taproot Channel Maturity

While Eclair supports taproot channels as of v0.14.0, these are currently limited to unannounced (private) channels. The gossip protocol for advertising public taproot channels is still being specified across implementations. Early adopters should be aware that the taproot channel ecosystem is still maturing.

Why It Matters

The Lightning Network's health depends on implementation diversity. If every node ran the same software, a single bug could cascade across the entire network. Eclair provides a critical alternative to LND and Core Lightning, with distinct architectural choices that catch different classes of bugs and enable different deployment patterns.

ACINQ's dual role as both a spec contributor and a large-scale node operator gives Eclair a unique feedback loop: protocol improvements are proposed, implemented, and stress-tested in production before being pushed to the broader ecosystem. Features like splicing and trampoline routing originated from real operational needs, not theoretical design. As the Lightning Network scales toward broader adoption, Eclair's enterprise architecture and ACINQ's protocol contributions will continue shaping the network's evolution.

This glossary entry is for informational purposes only and does not constitute financial or investment advice. Always do your own research before using any protocol or technology.