Software and SDKs
There are two key pieces of network software: Stellar Core, which tracks and adds transaction sets to the ledger, and Horizon, an API that allows programmatic access to submit transactions and query network data. To find out more about how they work together, visit the description of the Stellar Stack.
You do not have to run a Stellar Core node or Horizon instance to build on Stellar: you can start developing in your language of choice by installing one of the Stellar SDKs below, and interacting with a public Horizon instance. To find out more about how to interact with Horizon, check out the API Reference section, which chronicles every Horizon endpoint, resource, aggregation, and error.
Stellar Core is the backbone of the Stellar network and does the hard work of validating and agreeing on the status of every transaction with other instances of Core through the Stellar Consensus Protocol. The processes for installing, configuring, and maintaining a Stellar Core node are covered in great detail in the Run a Core Node section of the docs.
Horizon is the client-facing API server for the Stellar ecosystem. It acts as the interface between Stellar Core and applications that want to access the Stellar network. If you’re running Stellar Core, you will probably also want to run Horizon. For more information on how to set up and operate a Horizon instance, see the Run an API Server section of the docs.
Each SDK has its own source code and documentation, and we’ve linked to both in the list below. Often, the best place to find out how to use a given SDK is to check the documentation specific to it. Most offer practical examples that demonstrate how to construct and submit transactions and interact with Horizon endpoints.
The Go SDK is split up into a few separate packages, all of which you can find in the Go monorepo README. The two key libraries for interacting with Horizon are
txnbuild, which enables the construction, signing, and encoding of Stellar transactions, and
horizonclient, which provides a web client for interfacing with Horizon server REST endpoints to retrieve ledger information and submit transactions built with
The Stellar Development Foundation maintains a small suite of tools to make it easier for developers to interact with the network.
The Stellar laboratory is a GUI that allows you to create accounts, construct and submit transactions, read XDRs, and query all of Horizon’s endpoints. It exposes the relevant calls to Horizon, so it’s a great way to experiment with and learn more about the Stellar API. The source is available here.
The account viewer is a stripped-down wallet that you can use to check an account’s XLM balance and send simple payments. It works on the testnet as well as the public network. The source is available here.
The dashboard shows the current status of the public network and the test network. The source is available here.
The status page tracks network incidents and scheduled maintenance for both the public network and the test network. We recommend subscribing to updates so you’re notified about important events including protocol upgrades and testnet resets.
There is also a small suite of tools built in Go that can be useful for Stellar Core and Horizon operators. It includes things like Stellar Archivist, which is for Stellar Core archive maintenance, and Horizon cmp, which compares the responses of two Horizon servers and shows the diffs.
The Stellar Development Foundation maintains reference implementations of some Stellar Ecosystem Proposals to jumpstart the process of building infrastructure on top of Stellar in a way that maximizes interoperabilit among ecosystem participants.
- Polaris is an extendable django app that makes it easy for anchors to enable deposits and withdrawals. Using Polaris, you can run a web server supporting any combination of SEP-1, 6, 10, 12, and 24.
- The SEP-24 demo client makes it easy for anchors to test their deposit and withdrawal flows by implementing the client side of a Stellar SEP24 interactive flow.
- The Federation Server is a Go implementation of the federation protocol described in SEP-2. It’s designed to be dropped into your existing infrastructure.
Last updated Sep. 23, 2020