grin/doc/build.md

# Grin - Build, Configuration, and Running

## Supported Platforms

Longer term, most platforms will likely be supported to some extent.
Grin's programming language `rust` has build targets for most platforms.

What's working so far?
* Linux x86\_64 and MacOS [grin + mining + development]
* Not Windows 10 yet [grin kind-of builds. No mining yet. Help wanted!]

## Requirements

- rust 1.26+ (use [rustup]((https://www.rustup.rs/))- i.e. `curl https://sh.rustup.rs -sSf | sh; source $HOME/.cargo/env`)
  - if rust is already installed, you can simply update version with `rustup update`
- clang
- ncurses and libs (ncurses, ncursesw5)
- zlib libs (zlib1g-dev or zlib-devel)
- pkg-config
- libssl-dev
- linux-headers (reported needed on Alpine linux)

For Debian-based distributions (Debian, Ubuntu, Mint, etc), all in one line (except Rust):
```
apt install build-essential cmake git libgit2-dev clang libncurses5-dev libncursesw5-dev zlib1g-dev pkg-config libssl-dev
```

## Build steps

```sh
git clone https://github.com/mimblewimble/grin.git
cd grin
cargo build --release
```
Grin can also be built in debug mode (without the `--release` flag, but using the `--debug` or the `--verbose` flag) but this will render fast sync prohibitively slow due to the large overhead of cryptographic operations.

## Mining in Grin

Please note that all mining functions for Grin have moved into a separate, standalone package called
[grin_miner](https://github.com/mimblewimble/grin-miner). Once your Grin code node is up and running,
you can start mining by building and running grin-miner against your running Grin node.

### Build errors

See [Troubleshooting](https://github.com/mimblewimble/docs/wiki/Troubleshooting)

## What was built?

A successful build gets you:

 - `target/release/grin` - the main grin binary

All data, configuration and log files created and used by grin are located in the hidden
`~/.grin` directory (under your user home directory) by default. You can modify all configuration
values by editing the file `~/.grin/grin-server.toml`.

It is also possible to have grin create its data files in the current directory. To do this, run

```
grin server config
```

Which will generate a `grin-server.toml` file in the current directory, pre-configured to use
the current directory for all of its data. Running grin from a directory that contains a
`grin-server.toml` file will use the values in that file instead of the default
`~/.grin/grin-server.toml`.

While testing, put the grin binary on your path like this:

```
export PATH=/path/to/grin/dir/target/debug:$PATH
```
Where path/to/grin/dir is your absolute path to the root directory of your Grin installation. 

You can then run `grin` directly (try `grin help` for more options).

# Configuration

Grin attempts to run with sensible defaults, and can be further configured via
the `grin-server.toml` file. This file is generated by grin on its first run, and
contains documentation on each available option. 

While it's recommended that you perform all grin server configuration via
`grin-server.toml`, it's also possible to supply command line switches to grin that
override any settings in the file.

For help on grin commands and their switches, try:

```
grin help
grin wallet help
grin client help
```

# Using grin

The wiki page [How to use grin](https://github.com/mimblewimble/docs/wiki/How-to-use-grin)
and linked pages have more information on what features we have,
troubleshooting, etc.

## Docker

        # Build using all available cores
        docker build -t grin .

        # run in foreground
        docker run -it -v grin:/usr/src/grin grin

        # or in background
        docker run -it -d -v grin:/usr/src/grin grin

If you decide to use a persistent storage (e.g. ```-v grin:/usr/src/grin```) you will need grin-server.toml configuration file in it.

### Cross-platform builds

Rust (cargo) can build grin for many platforms, so in theory running `grin`
as a validating node on your low powered device might be possible.
To cross-compile `grin` on a x86 Linux platform and produce ARM binaries,
say, for a Raspberry Pi.