Industry Insights

The Stellar Foundation Roadmap for 2026: Key Milestones and What Developers Should Know

The Stellar Development Foundation (SDF) has laid out an ambitious roadmap for 2026, focusing on scalability, developer experience, and positioning Stellar as the blockchain of choice for regulated financial applications. Whether you're building payment apps, tokenization platforms, or DeFi protocols, these changes will impact how you architect and deploy your applications.

The Big Picture: Stellar's 2026 Vision

SDF's roadmap centers around four pillars:

  • Scalability - Reaching ~5000 TPS to handle institutional transaction volumes
  • Unified Data Access - Consolidating Soroban RPC into Stellar RPC
  • State Management - Improving state archival for cheaper long-term storage
  • Developer Experience - Better SDKs, tooling, and documentation
  • Let's break down each area and what it means for your applications.

    Pillar 1: Scaling to 5000 TPS

    Where We Are

    Stellar currently handles approximately 100-200 TPS during peak activity. While this is already faster than many blockchains, institutional use cases like real world asset tokenization demand significantly higher throughput.

    You can monitor current TPS and network metrics on our Stellar Network Analytics Dashboard, which shows real-time ledger data.

    How They're Getting There

    The path to ~5000 TPS involves several optimizations:

    Consensus Layer Improvements:

  • Optimized SCP (Stellar Consensus Protocol) message handling
  • Reduced inter-validator communication overhead
  • Parallel transaction application within ledgers
  • Horizon Infrastructure:

  • Improved ingestion pipeline for higher throughput
  • Better database indexing for faster queries
  • Connection pooling and caching improvements
  • For a deeper analysis of how these changes affect API integrations, see our post on how Stellar's 5000 TPS roadmap impacts your API integrations.

    What Developers Should Do

  • Design for higher throughput - Your applications should handle increased data volumes
  • Use streaming over polling - SSE connections are more efficient at scale (our Live Transaction Viewer demonstrates this pattern)
  • Implement proper caching - Use Redis or similar to avoid hitting rate limits
  • Monitor with LumenQuery - Our Analytics Dashboard provides real-time network health metrics
  • Pillar 2: Stellar RPC Unification

    The Rebrand

    Soroban RPC is becoming Stellar RPC. This isn't just a name change—it represents a fundamental shift in how developers access network data. We covered this transition in detail in our post on the Soroban to Stellar RPC rebrand.

    What Changes

    Before (two interfaces):

  • Horizon API: Payments, accounts, offers, ledger history
  • Soroban RPC: Smart contract state, transaction simulation, events
  • After (clear separation):

  • Stellar RPC: Real-time state, simulation, submission
  • Horizon API: Historical data, deep indexing, full-text search
  • How to Use Stellar RPC

    Learn to query real-time blockchain data using Stellar RPC in our hands-on guide: Using the Stellar RPC to Access Real-Time Blockchain Data.

    Key RPC methods every developer should know:

    # Check network health
    curl -X POST https://rpc.lumenquery.io \
      -d '{"jsonrpc":"2.0","method":"getHealth","id":1}'
    
    # Get latest ledger
    curl -X POST https://rpc.lumenquery.io \
      -d '{"jsonrpc":"2.0","method":"getLatestLedger","id":1}'
    
    # Simulate a transaction before submitting
    curl -X POST https://rpc.lumenquery.io \
      -d '{"jsonrpc":"2.0","method":"simulateTransaction","id":1,
           "params":{"transaction":"AAAAAgAA..."}}'

    LumenQuery provides managed access to both Horizon and Stellar RPC. See our API documentation for the full endpoint reference.

    Pillar 3: State Archival Improvements

    The Problem

    Every smart contract on Stellar stores data (state) that validators must maintain. As more contracts are deployed, state bloat becomes a concern—it slows down validators and increases costs.

    The Solution

    SDF's state archival strategy involves:

  • Tiered storage - Frequently accessed data stays in "live" state; older data moves to archival
  • Rent-based economics - Contracts pay rent to keep data in live state
  • Efficient restoration - Archived state can be restored with a single transaction
  • Cheaper storage - Archival storage costs significantly less than live state
  • Impact on Developers

    If you're building Soroban smart contracts, you need to understand state archival:

  • Use temporary storage for ephemeral data (cheaper, auto-expires)
  • Use persistent storage only for data that must survive across transactions
  • Budget for rent payments in your contract economics
  • Our Soroban Smart Contracts Explorer documentation explains the three storage types (persistent, temporary, instance) and when to use each.

    Pillar 4: Developer Experience

    SDK Improvements

    SDF is investing in better SDKs across multiple languages:

  • JavaScript/TypeScript - @stellar/stellar-sdk with improved TypeScript support
  • Rust - First-class Soroban SDK for contract development
  • Python - Growing community SDK
  • Go - Used by many institutional integrators
  • Tooling

    The developer toolchain is expanding:

  • Stellar CLI - One tool for contract deployment, testing, and interaction
  • Soroban Dev Environment - Local testing without connecting to testnet
  • Improved Block Explorers - Like LumenQuery's Smart Contract Explorer for decoded contract data
  • Grant Programs

    SDF continues to fund ecosystem development through:

  • Community Fund - Grants for open-source projects
  • Startup Programs - Funding for companies building on Stellar
  • Bounty Programs - Rewards for specific development tasks
  • Read more about these initiatives in our post on how Stellar is expanding the developer ecosystem.

    Timeline: Key 2026 Milestones

    QuarterMilestoneImpact
    Q1 2026Stellar RPC GAUnified data access for all apps
    Q2 2026State archival v2Cheaper contract storage
    Q2 2026Protocol 22New transaction types, improved SCP
    Q3 20262000 TPS target10x current capacity
    Q4 2026Enhanced SorobanMore complex contract capabilities
    2027+5000 TPS targetInstitutional-grade throughput

    How to Prepare Your Applications

    1. Start Using Stellar RPC

    Begin migrating from Soroban RPC to Stellar RPC now. LumenQuery supports both endpoints during the transition:

    # LumenQuery Horizon API (historical data)
    curl https://api.lumenquery.io/ledgers?limit=5
    
    # LumenQuery Stellar RPC (real-time state)
    curl -X POST https://rpc.lumenquery.io \
      -d '{"jsonrpc":"2.0","method":"getLatestLedger","id":1}'

    2. Monitor Network Changes

    Use our Analytics Dashboard to track protocol upgrades and network metrics. When the protocol version increments, check for new features.

    3. Test Against Realistic Conditions

    Our Natural Language Query Interface lets you explore live network data to understand transaction patterns and asset flows.

    4. Stay Updated

    Follow these resources to stay informed:

  • LumenQuery Blog - Developer guides and industry analysis
  • Stellar Developer Docs - Official SDF documentation
  • SDF Blog - Announcements and roadmap updates

  • Related reading:

  • How the Stellar Foundation Is Driving Real World Asset Adoption
  • Using the Stellar RPC to Access Real-Time Blockchain Data
  • How Stellar's Roadmap to 5000 TPS Impacts Your API Integrations
  • Best Stellar API Providers in 2026