# How to Build croc from Source: Complete Installation Guide

> Build croc from source with our complete installation guide. Install Go, clone the repository, and compile the binary or use go install for a quick setup.

- Repository: [Zack/croc](https://github.com/schollz/croc)
- Tags: tutorial
- Published: 2026-07-27

---

**Build croc from source by installing Go 1.22 or newer, cloning the schollz/croc repository, and running `go build -o croc ./main.go` to compile the binary, or use `go install github.com/schollz/croc/v10@latest` to install directly to your Go bin directory.**

The schollz/croc secure file transfer tool is written in Go and follows conventional project layouts, making it straightforward to build croc from source across Linux, macOS, and Windows. Whether you need the latest unreleased features or want to audit the code before compilation, building from source ensures you have complete control over the binary. This guide covers the exact steps using the officially supported build methods documented in the repository.

## Prerequisites

Before you build croc from source, ensure you have the following installed. These tools handle the compilation and dependency management automatically.

- **Go 1.22 or newer** – The project requires a recent Go version to compile correctly. Download the latest stable release from [go.dev](https://go.dev/dl/).
- **Git** – Required only if you choose to clone the repository instead of using `go install`.

## Method 1: Build from Cloned Repository

This approach downloads the full source code to your machine and compiles the binary locally. This method is ideal when you need to inspect the implementation in [`src/cli/cli.go`](https://github.com/schollz/croc/blob/main/src/cli/cli.go) or modify the transfer logic in [`src/croc/croc.go`](https://github.com/schollz/croc/blob/main/src/croc/croc.go) before compiling.

### Clone the Repository

Use Git to fetch the source code from the official repository:

```bash
git clone https://github.com/schollz/croc.git
cd croc

```

### Compile the Binary

The entry point for the CLI is located in [`main.go`](https://github.com/schollz/croc/blob/main/main.go) at the repository root. Run the following command to build the executable:

```bash
go build -o croc ./main.go

```

This produces a `croc` binary in your current directory. The build automatically fetches required dependencies—including `github.com/schollz/logger` and `github.com/schollz/pake/v3`—via Go modules declared in `go.mod`. No manual dependency management is required.

Run the binary directly to verify:

```bash
./croc --version

```

## Method 2: Install Using go install

If you do not need the source code locally, use `go install` to build and install croc directly to your Go binary directory. This method skips the cloning step and compiles the latest stable version immediately.

```bash
go install github.com/schollz/croc/v10@latest

```

This command pulls the latest tagged version from the repository, compiles it, and places the binary in `$GOPATH/bin` (or `$HOME/go/bin` by default on most systems). Ensure this directory is included in your system's `PATH` variable to run `croc` from any location:

```bash
croc --version

```

## Key Source Files and Project Structure

Understanding the repository layout helps when modifying or debugging your build. The schollz/croc project organizes code into these critical files according to standard Go conventions:

- **[`main.go`](https://github.com/schollz/croc/blob/main/main.go)** – The entry point that builds the CLI binary.
- **`go.mod`** – Declares the module path and defines required dependencies.
- **[`src/cli/cli.go`](https://github.com/schollz/croc/blob/main/src/cli/cli.go)** – Implements command-line interface logic and sub-commands.
- **[`src/croc/croc.go`](https://github.com/schollz/croc/blob/main/src/croc/croc.go)** – Contains core logic for encrypted file transfers.
- **`src/install/Makefile`** – Provides make targets for automated building and system-wide installation.

## Verify Your Installation

After building croc from source, confirm the binary works correctly by checking its version. This ensures the compilation succeeded and the binary is ready for secure file transfers.

```bash

# For locally built binary

./croc --version

# For go install method

croc --version

```

A successful build displays the current version string without errors.

## Summary

- **Go 1.22+ is required** to compile croc from source.
- **Two build methods exist:** Direct compilation with `go build -o croc ./main.go` after cloning, or remote installation via `go install github.com/schollz/croc/v10@latest`.
- **Dependencies are automatic** – Go modules handle downloads of packages like `github.com/schollz/logger` without manual intervention.
- **Key files** include [`main.go`](https://github.com/schollz/croc/blob/main/main.go) for the entry point and [`src/croc/croc.go`](https://github.com/schollz/croc/blob/main/src/croc/croc.go) for transfer logic.
- **Verification** is done by running `croc --version` on the compiled binary.

## Frequently Asked Questions

### What version of Go do I need to build croc from source?

You need **Go 1.22 or newer**. The project uses language features and standard library packages introduced in recent versions, and this requirement is enforced in the `go.mod` file found in the repository root.

### Can I use the Makefile to build croc from source?

Yes. The repository includes **`src/install/Makefile`** which contains build targets for compiling and installing the binary. While the manual `go build` approach offers more control during development, the Makefile provides convenient shortcuts for system-wide installations and packaging workflows.

### Where does the go install method place the croc binary?

By default, `go install` places the binary in **`$HOME/go/bin`** (or `$GOPATH/bin` if you have set a custom `GOPATH`). You must add this directory to your system's `PATH` environment variable to execute `croc` without specifying the full path.

### Do I need to install dependencies manually when building croc from source?

No. Go automatically resolves and downloads required dependencies—such as `github.com/schollz/pake/v3` for cryptographic operations—when you run `go build` or `go install`. These dependencies are defined in the `go.mod` file and fetched from their remote repositories during the first build.