# Compilers and cross-compilation

To use a compiler in your project, it's best to use the `${{ compiler('lang')
}}` template function. The compiler function works by taking a language,
determining the configured compiler for that language, and adding some
information about the target platform to the selected compiler. To configure a
compiler for a specific language, the `variant_config.yaml` file can be used.

For example, in a recipe that uses a C-compiler, you can use the following code:

```yaml
requirements:
  build:
    - ${{ compiler('c') }}
```

To set the compiler that you want to use, create a variant config that looks
like the following:

```yaml
c_compiler:
  - gcc

# optionally you can specify a version
c_compiler_version:
  - 9.3.0
```

When the template function is evaluated, it will look something like:
`gcc_linux-64 9.3.0`. You can define your own compilers. For example, for Rust
you can use `${{ compiler('rust') }}` and `rust_compiler_{version}` in your
variant config.

## Cross-compilation

Cross-compilation is supported by `rattler-build` and the compiler template
function is part of what makes it possible. When you want to cross-compile from
`linux-64` to `linux-aarch64` (i.e. intel to ARM), you can pass `--target-platform
linux-aarch64` to the `rattler-build` command. This will cause the compiler
template function to select a compiler that is configured for `linux-aarch64`.
The above example would resolve to `gcc_linux-aarch64 9.3.0`. Provided that the
package is available for `linux-64` (your build platform), the compilation
should succeed.

The distinction between the `build` and `host` sections begins to make sense when
thinking about cross-compilation. The `build` environment is resolved to
packages that need to _run_ at compilation time. For example, `cmake`, `gcc`,
and `autotools` are all tools that need to be executed. Therefore, the `build`
environment resolves to packages for the `linux-64` architecture (in our
example). On the other hand, the `host` packages resolve to `linux-aarch64` -
those are packages that we want to link against.

```yaml
# packages that need to run at build time (cmake, gcc, autotools, etc.)
# in the platform that rattler-build is executed on (the build_platform)
build:
  - cmake
  - ${{ compiler('c') }}
# packages that we want to link against in the architecture we are
# cross-compiling to the target_platform
host:
  - libcurl
  - openssl
```