.svg){kind=icon}
Now hiring!
•
In the evolving Starknet ecosystem, staking and decentralization is gaining attention and Juno stands out. But what exactly is Juno, and why should you care? Whether you're a developer, node operator, or blockchain enthusiast, this blog will guide you through everything you need to know about this groundbreaking Starknet full-node client that's reshaping decentralization.
Before diving into Juno, it's essential to understand the ecosystem it serves. Starknet is a Validity-Rollup (ZK-Rollup) Layer 2 network that operates on top of Ethereum, enabling decentralized applications to massively scale without compromising security.
Imagine trying to fit an elephant (the world's transaction volume) into an Aston Martin (Ethereum). No matter how hard you push, that elephant isn't getting in, at least not all at once. This is essentially the blockchain scaling problem. Starknet's solution? Don't try to stuff the whole elephant into the car. Instead, take photos of the elephant (compress the data with STARK proofs), and put those in the car instead. The photos take up much less space but still prove the elephant exists!
This solution works remarkably well. In October 2024, Starknet demonstrated its scaling capabilities by processing an incredible 857 transactions per second (TPS), with an average of 127 TPS sustained over 24 hours. These transactions confirmed in under 2 seconds on average, with ultra-low fees of approximately $0.002 per transaction. This performance milestone was achieved during a popular tile-flipping game called Flippy Flop which showcased Starknet's readiness for mass adoption, handling transaction volumes that would cripple many other networks.
Starknet addresses blockchain's core scaling constraints through STARK proof technology. By processing transactions off-chain and submitting cryptographic proofs to Ethereum, the network delivers high performance without security compromises. This architecture enables higher throughput, faster confirmations, and reduced costs while inheriting Ethereum's security foundation.
The Starknet architecture consists of three primary components:
Juno is an open-source Go implementation of a Starknet full-node client, developed by Nethermind. It's designed to enable permissionless involvement in the Starknet ecosystem and support various node setups, from light clients to full nodes to sequencers.
"Think of Juno as your personal gateway to the Starknet universe, independent of any central authority."
Also the name "Juno" is intentional. In Roman mythology, Juno was the goddess of protection and guardian of the community which is what we mean to support as we enable the decentralization of Starknet.
Having multiple client implementations in different programming languages is crucial for network resilience. If all nodes ran the same software, a single bug could crash the entire network. This is exactly what happened to Ethereum in 2016 with the "Shanghai DoS attacks" when a bug in the dominant Geth client affected many of the nodes.
Go (or Golang) brings several key benefits to Juno's architecture:
These advantages translate into a node implementation that's lightweight, performant, and accessible to a broad developer community which are critical factors for a node implementation aimed at supporting network decentralization.
Juno uses a path-based trie storage system which offers significant efficiency advantages.
For example:
When state updates occur, Juno's path-based system can efficiently replace just the necessary data at its specific path, rather than maintaining multiple versions of the same state. This approach significantly reduces storage requirements and improves lookup performance.
Juno's synchronization process is like a well-orchestrated assembly line with three specialized stations:
A major feature is Juno's Snap Sync feature. Traditional blockchain synchronization is like reading a 1,000-page novel from page 1 to understand the ending. Snap Sync is like skipping to the last chapter and getting a perfect summary of everything important that happened before.
This approach can reduce initial sync time from days to hours which is a crucial advantage for new node operators eager to join the network.
Juno implements the full Starknet JSON-RPC API specification, think of it as speaking the native language of the Starknet ecosystem fluently and without accent. This includes support for multiple API versions:
.svg)
.svg)
.svg)
.svg)
.svg)
.svg){kind=icon}
.svg)
.svg)
.svg)
.svg)
.svg)
.svg)
.svg)
.svg)
// Accessing the same endpoint across different API versions
v0.8.0: http://localhost:6060/
v0.7.0: http://localhost:6060/v0_7
v0.6.0: http://localhost:6060/v0_6
This backward compatibility ensures applications built for earlier Starknet versions continue to work seamlessly with Juno.
The API provides rich functionality for interacting with the blockchain:
And for applications needing real-time updates, Juno's WebSocket interface is like having a dedicated news reporter on the blockchain:
// WebSocket subscription example
const ws = new WebSocket('ws://localhost:6061');
ws.send(JSON.stringify({
jsonrpc: "2.0",
method: "starknet_subscribeNewHeads",
params: [],
id: 1
}));
// Now you'll receive real-time notifications when new blocks are added!
ws.onmessage = (event) => {
console.log('New block:', JSON.parse(event.data));
};
This real-time capability gives developers superpowers when building responsive applications.
Juno tracks Starknet's state, and verifies it against Ethereum (L1), ensuring what happens on Layer 2 is accurately reflected on Layer 1.
This verification process adds an additional layer of security and trust to the Starknet ecosystem. For applications handling significant value, this feature provides crucial peace of mind.
Juno's plugin system allows developers to extend and customize its functionality without modifying the core codebase. Plugins implement the JunoPlugin interface, which provides hooks for initialization, shutdown, and processing blockchain events.
Here's a basic example of a Juno plugin from the documentation:
// go:generate go build -buildmode=plugin -o ../../build/plugin.so ./example.go
type examplePlugin string
// Important: "JunoPluginInstance" needs to be exported for Juno to load the plugin correctly
var JunoPluginInstance examplePlugin
var _ junoplugin.JunoPlugin = (*examplePlugin)(nil)
func (p *examplePlugin) Init() error {
fmt.Println("ExamplePlugin initialized")
return nil
}
func (p *examplePlugin) Shutdown() error {
fmt.Println("ExamplePlugin shutdown")
return nil
}
func (p *examplePlugin) NewBlock(block *core.Block, stateUpdate *core.StateUpdate, newClasses map[felt.Felt]core.Class) error {
fmt.Println("ExamplePlugin NewBlock called")
return nil
}
func (p *examplePlugin) RevertBlock(from, to *junoplugin.BlockAndStateUpdate, reverseStateDiff *core.StateDiff) error {
fmt.Println("ExamplePlugin RevertBlock called")
return nil
}
The JunoPlugin interface includes four essential methods:
Init(): Called when the plugin is initializedShutdown(): Called when the Juno node is shutting downNewBlock(): Triggered when a new block is synced, providing access to the block data, state updates, and new classesRevertBlock(): Called during blockchain reorganizations to handle state reversions
To use a plugin, you compile it as a shared object file and load it with Juno using the --plugin-path flag. This architecture enables developers to implement custom indexers, monitoring tools, and integrations while maintaining compatibility with future Juno updates.
The Juno documentation provides comprehensive guides on developing plugins for various use cases on top of the base node functionality:
Each plugin can process the same blockchain data but extract different insights or perform distinct actions, all without requiring modifications to Juno's core codebase.
An exciting aspect of Juno's roadmap is its progression toward becoming a Starknet sequencer. When implemented, Juno will actively participate in Layer 2 consensus to secure the network, operating in three modes:
This will enable Starknet's decentralization by distributing transaction processing across multiple independent nodes, preventing any single entity from controlling the network.
By enabling multiple clients to participate in consensus, Juno helps create a more resilient, censorship-resistant, and truly decentralized Starknet ecosystem.
Juno has a number of methods to quickly and easily get started running and supporting Starknet!
If you've ever assembled IKEA furniture, you know the difference between a 50-step process and a 3-step process. Docker makes running Juno as simple as the latter:
# Step 1: Pull the Docker image (like unboxing the parts)
docker pull nethermind/juno
# Step 2: Create a directory for your node data (like clearing space on your table)
mkdir -p $HOME/snapshots
# Step 3: Launch the container (like putting the three main pieces together)
docker run -d \
--name juno \
-p 6060:6060 \
-v $HOME/snapshots/juno_mainnet:/snapshots/juno_mainnet \
nethermind/juno \
--http \
--http-port 6060 \
--http-host 0.0.0.0 \
--eth-node <YOUR-ETH-NODE> \
--db-path /snapshots/juno_mainnet
That's it! No "insert tab A into slot B" nightmares. Your Juno node will begin synchronizing with the Starknet network immediately. As one developer put it in a GitHub issue: "I spent two days trying to get Pathfinder running properly. Got Juno up in 10 minutes. Never going back."
For those who prefer to avoid Docker (perhaps you've been traumatized by containers in the past), Juno provides precompiled binaries for various platforms:
# Download the appropriate binary for your system from
# https://github.com/NethermindEth/juno/releases
# Run the downloaded binary
./juno \
--http \
--http-port 6060 \
--http-host 0.0.0.0 \
--eth-node <YOUR-ETH-NODE> \
--db-path $HOME/snapshots/juno_mainnet
The binary approach gives you that "bare metal" feeling some developers crave, without the complexity of building from source.
For the technical gourmets who prefer to cook from scratch rather than ordering takeout, building from source gives you maximum control:
# Clone the repository
git clone https://github.com/NethermindEth/juno
cd juno
# Build the binary (this is where you'd go make coffee if using Rust!)
make juno # With Go, you probably won't even have time to reach the coffee machine
# Run your freshly built binary
./build/juno \
--http \
--http-port 6060 \
--http-host 0.0.0.0 \
--eth-node <YOUR-ETH-NODE>
The speed of Go compilation means you won't be staring at progress bars for half an hour—typically, Juno builds in under a minute on modern hardware. Compare that to some Rust-based nodes where compilation can take 15-20 minutes!
Perhaps the most brilliant feature in Juno's easy-setup arsenal is snapshot support. Syncing a blockchain from scratch is like downloading the entire history of Wikipedia which means it will take time. Snapshots are like getting a pre-loaded Wikipedia database:
# Download the latest snapshot
wget -O juno_mainnet.tar https://juno-snapshots.nethermind.io/files/mainnet/latest
# Extract the snapshot
tar -xvf juno_mainnet.tar -C $HOME/snapshots
# Run Juno using the snapshot data
docker run -d \
--name juno \
-p 6060:6060 \
-v $HOME/snapshots/juno_mainnet:/var/lib/juno \
nethermind/juno \
--http \
--http-port 6060 \
--http-host 0.0.0.0 \
--db-path /var/lib/juno \
--eth-node <YOUR-ETH-NODE>
With snapshots, you can have a fully synchronized Starknet node significantly faster than synchronizing from genesis. This approach lets you quickly deploy operational nodes ready for production workloads. Snapshot sizes vary by network, with Sepolia currently around 30GB and mainnet approaching or exceeding 300GB.
For detailed setup instructions and troubleshooting tips, the Juno documentation provides comprehensive guides for all deployment methods. The community on Discord and Telegram is also remarkably helpful if you encounter any issues, our engineers regularly check in to answer questions and provide support directly.
Juno shines in scenarios where ease of deployment, resource efficiency, and quick synchronization are priorities. As one DevOps engineer put it: "Our team went from 'blockchain is complicated' to 'we have three Starknet nodes running' in a single afternoon with Juno."
For developers building on Starknet, these differences can translate to significant cost savings, especially when running multiple nodes across development, staging, and production environments.
Beyond performance metrics, it's worth highlighting Juno's unique contribution to the ecosystem: it's the only major Starknet node written in Go. This diversity isn't just a technical footnote—it's crucial for network resilience. If a critical bug affected Rust implementations, Juno nodes would continue operating, providing essential redundancy.
The Nethermind team has emphasized this diversity as a central pillar of their development philosophy. In their words: "Multiple independent implementations are not a luxury, they're a necessity for truly decentralized networks."
As Starknet's ecosystem matures, Juno is evolving beyond basic node operation to support network validation. With Juno's latest versions, users can participate in Starknet's validator system to contribute to network security and earn rewards.
Think of validators as the blockchain equivalent of election officials , they ensure that every transaction follows the rules and that the final tally (the blockchain state) is accurate. And like election officials, they're compensated for this critical service.
The process of becoming a validator involves three main steps:
The rewards can be substantial, with validators earning a portion of transaction fees and protocol rewards. However, as with any blockchain staking, there are risks involved, including potential slashing if your node behaves maliciously or experiences extended downtime.
One validator shared their experience: "Setting up a validator node with Juno was surprisingly straightforward. The hardest part was actually acquiring the STRK tokens, not the technical setup!"
For those interested in this path, the Juno documentation includes a dedicated validator guide with step-by-step instructions and best practices for secure operation.
Juno's roadmap toward becoming a Starknet sequencer represents a crucial step for the network's decentralization. By distributing transaction processing across multiple independent nodes, Juno ensures Starknet remains:
As more Juno nodes join the network, developers gain reliable infrastructure for building truly decentralized applications, creating a foundation for Starknet's continued growth and innovation.
Juno represents a crucial step in Starknet's journey toward full decentralization. By providing a Go-based alternative to existing node implementations, it enhances network resilience and accessibility while addressing the core challenge of centralized sequencing.
The technical achievements are impressive: a path-based trie that optimizes storage, a three-stage syncing pipeline that ensures data integrity, comprehensive API support across multiple versions, and an extensible plugin architecture. But Juno's real achievement is how it combines these elements into a cohesive whole that's remarkably easy to deploy and operate.
In the words of Nethermind's Founder Tomasz Stańczak:
"Starknet enters an important phase of its development — one where it becomes more open, composable, trustless, and more trusting. I see my role at the foundation as an opportunity to foster collaboration, and support a move towards the future of decentralized and permissioned chains powered by STARKs."
Whether you're a developer looking to build on Starknet, a node operator seeking to support the network, or simply a blockchain enthusiast curious about Layer 2 solutions, Juno offers an exciting opportunity to participate in shaping the future of blockchain scalability.
The road to true decentralization is long and winding, with technical and governance challenges at every turn. But with tools like Juno, we're well on our way to creating Layer 2 solutions that deliver on the original promise of blockchain: systems that are secure, scalable and decentralized.
As we like to say in the blockchain world: the future isn't just distributed, it's Juno-powered!
Remember, every node counts in the journey toward decentralization. Your contribution, whether as a developer, node operator, or simply a vocal supporter, helps build a more resilient and accessible blockchain ecosystem for everyone.
.svg)
Building blocks for the decentralized future
Nethermind © 2025
.png)
