I went through the site but I don't see how Stellar differs from Ripple. I see that there are differences in distribution, everything is made open source from day one and the company is non profit instead of for profit as in Ripple.

Both were co-founded by the same person and the technology seems to be the same.

What am I missing?

[Note: This answers the question as written and at the time it was written (and for quite some time afterwords). See a later answer for the current state.]

The Stellar code is a straight fork of Ripple with mostly trivial changes. It does have certain controversial features omitted (I assume on purpose) such as freezing. From a server and protocol perspective it has the exact same strengths (and weaknesses!) as Ripple does.

The client appears to have have had much functionality hidden/removed. For example it's currently impossible to set up trust lines.

The internal "currency" (transaction tokens) has been renamed from XRP (ripples) to STR (stellars). Sadly, "STR" doesn't even attempt to be ISO 4217 compatible. The STR distribution model differs from the XRP distribution model including an "inflation" feature whereby new STR is issued (and for the foreseeable future, goes to the "Steller Development Foundation").

  • 3
    Further to this, a blog post describing the server code changes. tl;dr: nothing useful – dchapes Aug 2 '14 at 21:57
  • 1
    This is no longer true. There is no code in common now. – Jed McCaleb Oct 20 '15 at 22:00

Stellar rewrote their code base using a different consensus algorithm (https://www.stellar.org/papers/stellar-consensus-protocol.pdf). Now the technology is quite different than ripple's.

  • 2
    Are you the same Jed McCaleb that's on the Stellar dev team? – Nick ODell Apr 14 '15 at 16:21
  • 5
    This answer is rather short. Could you please provide more details and some examples? – Murch Apr 14 '15 at 16:48
  • 2
    @NickODell yep that's me – Jed McCaleb Oct 20 '15 at 22:00

Stellar actually consists of two entirely different code bases at this point. It started out as a fork of the ripple code base. That software, called stellard, is still running in production. However, about half a year after launching, Stellar subsequently released a completely unrelated payment system called stellar-core. Stellar core is based on a new consensus algorithm (called SCP), and an entirely new code base. Because it is a clean slate design, there is no backwards compatibility and any transition will presumably take the form of either a flag day or trading old stellars for new stellars while both networks run for a period.

Stellar-core has many differences from stellard (and hence ripple). One of the big differences is the new consensus algorithm, SCP, which was released with a proof of safety and boasts being "optimally safe" for a given configuration and failure pattern. SCP allows a lot of flexibility in terms of how nodes configure their quorums, and is explicitly designed to accommodate Byzantine failures (where bad nodes lie) and different nodes trusting different subsets of the system. By contrast, ripple uses a fixed 80% threshold, and their analysis does not apply to cases in which different nodes have different sets of nodes to trust. (If what ripple calls the unique node list, or UNL, is not the same everywhere, then safety proof does not apply.)

There are numerous other differences between the two systems at both the implementation and protocol level. For instance ripple allows freezing currency one has issued, which Stellar does not seem to support (at least yet). Stellar is explicitly inflationary, with 1% new coins being created every year and all fees being recycled, while ripple destroys fees, meaning the total number of ripples in existence is slowly diminishing over time. Stellar uses the Ed25519 signature scheme (basically Schnorr) and 32-byte public keys as addresses, while ripple uses ECDSA and 20-byte hashes as addresses. At the implementation level, stellar's protocol is specified using Sun XDR, whereas ripple uses a combination of google protobufs and hand-written marshaling code.

  • 1
    Note: Due to a network fork, the stellar network now follows a single validating node. stellar.org/blog/… – Nick ODell Oct 21 '15 at 0:01
  • @NickODell Yeah, that was the old stellard based on rippled. The new stellar-core uses an algorithm (SCP) that guarantees consistency across multiple nodes. It's still in beta, but there are already five different organizations running nodes. github.com/stellar/docs/blob/master/validators.md – user3188445 Oct 22 '15 at 0:49

Although the question has been answered, but the following are the major differences I have observed about Stellar and Ripple which I felt was omitted

  1. The consensus algorithms are not the same, stellar uses (Stellar Consensus Protocol)SCP, SCP is the first provably safe consensus mechanism that simultaneously enjoys four key properties: decentralized control, low latency, flexible trust, and asymptotic security. Ripple uses probabilistic voting Those are fairly different even though they both tackle the same problem of reaching consensus between nodes. SCP biases towards correctness at the expense of liveness; Ripple follows a model similar to Bitcoin allowing ledger forks to occur temporarily and relying on majority validation.
  2. The native currency of stellar is Lumen(XLM) and that of ripple is (XRP)
  • 1
    As a minor comment: SCP is provably secure in a very specific (and very restrictive) model, but we have no idea whether this corresponds to reality. Especially the transitivity and the strong connectedness of the network are pretty strong assumptions. – cdecker Nov 24 '16 at 15:22
  • I don't see how point number 2 can count as a difference :) – mihai Apr 16 at 18:20

Your Answer

 
discard

By clicking "Post Your Answer", you acknowledge that you have read our updated terms of service, privacy policy and cookie policy, and that your continued use of the website is subject to these policies.

Not the answer you're looking for? Browse other questions tagged or ask your own question.