Getting Started

👐 The easiest way to get started with Gear is to use a demo environment on https://idea.gear-tech.io.
🔧 Follow the instructions from "Getting started in 5 minutes" to compile the Rust test smart contract to WebAssembly. 🏃 Upload and run smart contract in Gear demo environment on https://idea.gear-tech.io, send a message to a program, check how it is going.
📜 Write your own smart contract or take one from the examples. A comprehensive amount of smart contract examples are available for your convenience and faster onboarding.
💻 Download and run your Gear node locally or create your own multi-node local testnet.
🐬 Deep dive to the Smart Contracts section of the Gear Wiki for more details about how to implement and run your dApp in Gear.

Run Gear Node

Gear node can run in a single Dev Net mode or you can create a Multi-Node local testnet or make your own build of Gear node.

Compile and launch node as described in Gear Node README. Alternatively, download nightly build of Gear node:
- Windows x64: gear-nightly-windows-x86_64.zip
- macOS M1: gear-nightly-macos-m1.tar.gz
- macOS Intel x64: gear-nightly-macos-x86_64.tar.gz
- Linux x64: gear-nightly-linux-x86_64.tar.xz
Run Gear node without special arguments to get a node connected to the testnet:
```
gear-node
```
One may run a local node in development mode for testing purposes. This node will not be connected to any external network. Use --dev argument for running the node locally and --tmp for storing the state in temporary storage:
```
gear-node --dev --tmp
```
Get more info about usage details, flags, available options and subcommands:
```
gear-node --help
```

Implement and run your own blockchain application

Write your own smart contract or take one from the available templates. Adapt a template in accordance to your business needs. Gear provides templates for many dApp types - DeFi, DAO, NFT, Wallet, Staking, Oracle and more. Application templates.
Test your smart contract off-chain, test it on-chain using a local node, then upload to Gear network.
Implement an interface for your dApp for interaction Gear network using JS API or use provided by Gear on https://idea.gear-tech.io.

Gear components

core - Gear engine for distributed computing core components.
node - Gear substrate-based node, ready for hacking 🚀.
gstd - Standard library for Gear smart contracts.
gear-js - jsonrpc API of Gear backend.
examples - Gear smart contract examples.

Go to https://docs.gear.rs to dive into the documentation on Gear crates.

What does Gear do?

Gear provides the easiest and most cost-effective way
to run WebAssembly programs (smart-contracts) compiled from
many popular languages, such as Rust, C/C++ and more.

Gear ensures very minimal, intuitive, and sufficient API
for running both newly written and existing programs
on multiple networks without the need to rewrite them.

Smart Contracts are stored in the blockchain’s state
and are invoked preserving their state upon request.

Gear enables a seamless transition to Web3,
enabling the running of dApps, microservices, middleware and open APIs.

🔥 Key features

Programs run in WASM VM (near-native code execution speed)
Unique 👑 : Parallelizable architecture (even greater speed)
Unique 👑 : Actor model for message-passing communications - secure, effective, clear
dApp in minutes using Gear libraries
Based on Substrate

Main capabilities

Gear enables anyone to create and run any custom-logic dApp and is a go-to solution for the following types of applications:

Run dApps that support business logic of any project in the decentralized Gear network (very fast). Upload programs to the network and interact with them.
Being a Polkadot parachain, Gear establishes cross-chain communications between other blockchains, allowing anyone to run a dApp in the Polkadot network in a very cost-less manner.
Join Substrate-supported blockchains in any other platform outside Polkadot.
A standalone instance running microservices, middleware, open API and more

Why?

The blockchain technology launched a rapid transition from centralized, server-based internet (Web2) to decentralized, distributed one (Web3).

Web3 introduces a new type of decentralized applications (dApps) that enable the existence of DeFi, DEX, Decentralized marketplaces, NFTs, Creators and Social Tokens.

Smart Contract is an equivalent of a microservice which is stored on the blockchain network and is the essential building block of a decentralized application.

Modern blockchains solve many issues of the older blockchain networks, such as:

Lack of scalability, low transaction speed, high transaction costs
Domain-specific development language (high barrier to entry)
Complex and inefficient native consensus protocols
Absence of intercommunication tools

But still have room for improvements due to:

Fixated, rigid native consensus protocols
Lack of interoperability with other networks

To resolve the interoperability issue, Parity technologies focused on creating a technology that connects every other blockchain:

Polkadot - a blockchain of blockchains. Provides a “relay chain” (the primary blockchain) that enables “parachains” (functional blockchains) to be deployed on top of it. All parachains are interconnected, creating a massive network of multifunctional blockchain services.
Substrate - a modular framework that allows to create custom-built blockchains with consensus mechanism, core functionality and security out of the box.

Building a blockchain with Substrate allows it to be deployed on any compatible relay chain such as Polkadot and Kusama Substrate serves as a layer of communication between the relay chain and the parachain

How does it work?

The internal flow of Gear:

Refer to the technical paper for some insights about how Gear works internally.

Contribution

You can request a new feature by creating a new Issue or discuss it with us on Discord. Here are some features in-prog or planned: https://github.com/gear-tech/gear/issues