ethereum

a revolutionary new platform for applications

news

Introduction

Status

Ether Sale

We have not yet announced the date nor the terms of our upcoming Ether sale.

We will do so via our twitter feed, this blog and all our other social channels.

Release date and Mining

We expect to launch our live mainnet in Q4 2014. All Ether generated on the testnet is 'play Ether' and is reset regularly to prevent its resale.

Client downloads

The current clients available on this site are purely proofs of concept intended for an advanced technical audience. They do not reflect the final UI of our reference clients.

Twitter

Tweets by @ethereumproject

Videos

Links

Forums

Blog

Code

Whitepaper

Yellow paper

Google+

Facebook

YouTube

Meetups

General FAQ

Writing Smart Contracts FAQ

GoLang code and Build FAQ

C++ code and Build FAQ

Meetup FAQ

Mining FAQ

download

Proof of Concept client

windows client

mac client

linux source

build from source

What

Ethereum is a platform and a programming language that makes it possible for any developer to build and publish next-generation distributed applications.

Ether, Ethereum's internal currency, powers its applications and acts as a 'token of exchange' on the decentralized network.

Ethereum can be used to codify, decentralize, secure and trade just about anything: voting, domain names, financial exchanges, crowdfunding, company governance, contracts and agreements of most kind, intellectual property, and even smart property thanks to hardware integration.

Ethereum borrows the concept of decentralized consensus that makes bitcoin so resilient, yet makes it trivial to build on its foundation. To find out more about how Ethereum works, consult the white and yellow papers.

…will you build with Ethereum?

Name Registration

if tx.value < block.basefee * 200:
    stop
if contract.storage[tx.data[0]] or tx.data[0] < 100:
    stop
contract.storage[tx.data[0]] = tx.data[1]

Metacoin Protocol

if tx.output[0] != MARKER:
    break
else if balance[tx.output[1]] < decode_value(tx.output[3]):
    break
else if not tx.hasSignature(tx.output[1]):
    break
else:
    balance[tx.output[1]] -= decode_value(tx.output[3]);
    balance[tx.output[2]] += decode_value(tx.output[3]);

Sub-currencies

 if tx.value < 100 * block.basefee:
    stop
elif contract.storage[1000]:
    from = tx.sender
    to = tx.data[0]
    value = tx.data[1]
    if to <= 1000:
        stop
    if contract.storage[from] < value:
        stop
    contract.storage[from] = contract.storage[from] - value
    contract.storage[to] = contract.storage[to] + value
else:
    contract.storage[MYCREATOR] = 10^18
    contract.storage[1000] = 1

Data Feed

if tx.sender != FEEDOWNER:
    stop
contract.storage[data[0]] = data[1]

Hedging Contract

if tx.value < 200 * block.basefee:
    stop
if contract.storage[1000] == 0:
    if tx.value < 1000 * 10^18:
        stop
    contract.storage[1000] = 1
    contract.storage[1001] = 998 * block.contract_storage(D)[I]
    contract.storage[1002] = block.timestamp + 30 * 86400
    contract.storage[1003] = tx.sender
else:
    ethervalue = contract.storage[1001] / block.contract_storage(D)[I]
    if ethervalue >= 5000:
        mktx(contract.storage[1003],5000 * 10^18,0,0)
    else if block.timestamp > contract.storage[1002]:
        mktx(contract.storage[1003],ethervalue * 10^18,0,0)
        mktx(A,(5000 - ethervalue) * 10^18,0,0)

Decentralized Autonomous Organizations

if tx.value < tx.basefee * 200:
    stop
if contract.storage[tx.sender] == 0:
    stop
k = sha3(32,tx.data[1])
if tx.data[0] == 0:
    if contract.storage[k + tx.sender] == 0:
        contract.storage[k + tx.sender] = 1
        contract.storage[k] += 1
else if tx.data[0] == 1:
    if tx.value <= tx.datan * block.basefee * 200 or contract.storage[k]:
        stop
    i = 2
    while i < tx.datan:
        contract.storage[k + i] = tx.data[i]
        i = i + 1
    contract.storage[k] = 1
    contract.storage[k+1] = tx.datan
else if tx.data[0] == 2:
    if contract.storage[k] >= contract.storage[2 ^ 255] * 2 / 3:
        if tx.value <= tx.datan * block.basefee * 200:
            stop
        i = 3
        L = contract.storage[k+1]
        loc = contract.storage[k+2]
        while i < L:
            contract.storage[loc+i-3] = tx.data[i]
            i = i + 1
if contract.storage[2 ^ 255 + 1] == 0:
    contract.storage[2 ^ 255 + 1] = 1
    contract.storage[C] = 1

Why?

Most of the services you use today have something in common: they are centralized. For example, when when you deposit money at your bank, you trust them to be honest, be secure and be independently audited. The same is true when you post pictures on Facebook, or an important document on Dropbox. History has proven time and time again that this model is flawed, but necessary, as ‘trustless’ operations have been so far both unprofitable and too complex to implement.

Enter Ethereum.

Applications built on Ethereum do not require their users to trust the developers with their personal information or funds. Ethereum not only addresses the issues described above, it also opens the door to whole new kinds of applications that have never been seen before

philosophy

Simplicity

Ethereum is a protocol that is open to all. Any programmer should be able to write smart contracts and Ethereum apps in languages they already are familiar with.

Programmers should also be able to implement the entire specification with relative ease, in order to minimize the influence that any specific individual or group could have on the protocol.

The Ethereum protocol should be as simple as possible, and optimizations which add complexity should not be included unless they provide a very substantial benefit.

Universality

Ethereum does not have "features". Instead, Ethereum provides a scripting language which you can use to construct any program you can think on top of a distributed network.

This has implications going far beyond finance and smart contracts. Imagine what sort of problems could be solved if software was executed in a cloud, was always auditable, and always trustable. This opens the door to the development of voting machines, health care systems, traffic navigation, etc. where users stay in control of their funds and personal information at all times, as part of a network that's both censorship and collusion-proof.

Modularity

Different elements of the Ethereum protocol should be designed to be as modular and autonomous as possible. During the course of development, it should be easy to make small modifications to the protocol in one place and have the entire stack continue to function as normal.

Innovations such as our Proof of Work algorithm, Patricia Trees and RLP should be implemented as separate libraries and made feature-complete even if Ethereum does not require their entire feature set.

The development of Ethereum should benefit the entire cryptocurrency ecosystem.

Non-Discrimination

The protocol should not attempt to actively restrict or prevent specific categories of usage. The regulatory mechanisms in the protocol should only be designed to regulate harm, not attempt to oppose specific undesirable applications.

For example, you should be able to run an infinite loop on top of Ethereum for as long as you are willing to keep paying the per computational step fee for it.

Agility

The details of the Ethereum protocol are not set in stone, although of course we will be extremely judicious about making modifications to high-level constructs such as the low-level VM language and the address system.

Computational tests taking place later on in the development process may lead us to discover that certain modifications to the algorithms or scripting languages could substantially improve scalability or security. If any such opportunities are found, we will certainly make use of them.

What can you make out of ether?

Create a Currency
and issue Shares

Contracts, Law and Escrow

Financial Instruments and Derivatives

Decentralized Organizations (DAOs)

Decentralized Voting

Decentralized Data Storage

Contracts are the main building blocks of Ethereum. A contract is a computer program that lives inside the distributed Ethereum network and has its own ether balance, memory and code. Every time you send a transaction to a contract, it executes its code, which can store data, send transactions and interact with other contracts.

Contracts are maintained by the network, without any central ownership or control. Contracts are written in languages instantly familiar to any programmer and powered by Ether, Ethereum's cryptofuel. You can find out more in our wiki.