How to Build croc from Source: Complete Installation Guide

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.
• 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 or modify the transfer logic in src/croc/croc.go before compiling.

Clone the Repository

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

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

Compile the Binary

The entry point for the CLI is located in main.go at the repository root. Run the following command to build the executable:

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:

./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.

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:

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 – The entry point that builds the CLI binary.
• go.mod – Declares the module path and defines required dependencies.
• src/cli/cli.go – Implements command-line interface logic and sub-commands.
• 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.

# 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 for the entry point and 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.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}