What Programming Languages Are Used in Croc Development?

Croc is primarily written in Go for its core CLI, networking, and encryption layers, with a secondary React-based web interface built in TypeScript, HTML, and CSS.

The schollz/croc repository is a multi-platform file transfer tool that leverages two distinct language ecosystems. While the performance-critical backend and command-line interface rely on Go, the optional browser-based UI utilizes modern web technologies for cross-platform accessibility.

Go: The Core Engine

Go serves as the foundation of Croc, handling all performance-critical operations including the CLI, peer-to-peer networking, encryption, and compression. The entire binary distributed to users is compiled from this codebase, making it the dominant language by both functionality and line count.

Key Go source files include:

• main.go – The entry point that initializes the CLI and parses command-line arguments
• src/comm/comm.go – Implements the networking layer for managing peer-to-peer connections
• src/crypt/crypt.go – Contains the AES-GCM encryption implementation securing file transfers
• src/compress/compress.go – Provides optional lz4 compression for transferred data

You can import Croc's networking primitives directly into your own Go applications:

package main

import (
	"github.com/schollz/croc/v2/src/comm"
)

func main() {
	// Create a new client with default settings
	client, err := comm.NewClient()
	if err != nil {
		panic(err)
	}
	// Use the client to send/receive data…
	_ = client
}

The comm.NewClient() function exposed in src/comm/comm.go provides programmatic access to Croc's transfer protocol without invoking the CLI binary.

TypeScript and JavaScript: The Web Interface

The optional web-based UI, served by the web-relay component, is built with React and Vite using TypeScript for type-safe client-side development. This layer provides a browser-based alternative to the command-line interface for users preferring graphical interactions.

Representative TypeScript files include:

• web/src/App.tsx – The main React component rendering the transfer interface
• web/src/main.tsx – The application bootstrap point mounting the React tree
• web/vite.config.ts – Build tooling configuration for the frontend bundler
• web/src/protocol/client.ts – Client-side logic communicating with the Go-based relay server

The TypeScript client code interfaces with the Go backend through WebSocket or HTTP connections, bridging the frontend and core engine:

// web/src/App.tsx – a minimal React component
import React from 'react';
import { startTransfer } from './protocol/client';

function App() {
  const handleUpload = async (e: React.ChangeEvent<HTMLInputElement>) => {
    if (e.target.files) {
      const file = e.target.files[0];
      await startTransfer(file);
    }
  };

  return (
    <div>
      <h1>croc Web Transfer</h1>
      <input type="file" onChange={handleUpload} />
    </div>
  );
}

export default App;

HTML and CSS: Frontend Presentation

Static markup and styling for the web interface are defined in standard web formats separate from the TypeScript logic. The web/index.html file serves as the static entry point loaded by browsers, while web/src/styles.css contains the CSS rules governing the visual presentation of the React components. These files work in conjunction with the TypeScript codebase to deliver the complete browser-based user experience.

Summary

• Go powers the core application logic, including the CLI binary, encryption (src/crypt/crypt.go), networking (src/comm/comm.go), and compression (src/compress/compress.go).
• TypeScript drives the optional React-based web interface located in the web/ directory, providing a graphical alternative to command-line usage.
• HTML and CSS handle the presentation layer for the web UI, with web/index.html serving as the entry point.
• The repository structure cleanly separates the Go backend from the TypeScript frontend, allowing each language to handle tasks aligned with its strengths.

Frequently Asked Questions

Is Croc written entirely in Go?

No, while the core file transfer logic, encryption, and CLI are implemented in Go, the project also includes a web-based interface built with TypeScript, React, HTML, and CSS located in the web/ directory. The Go binary can function independently without the web components.

Can I use Croc as a library in my own Go projects?

Yes, the src/comm package exposes public APIs for programmatic use. As shown in src/comm/comm.go, you can import github.com/schollz/croc/v2/src/comm and instantiate clients directly via comm.NewClient() to integrate secure file transfer capabilities into your applications.

What encryption does Croc use in its Go implementation?

According to the source code in src/crypt/crypt.go, Croc implements AES-GCM (Galois/Counter Mode) encryption for securing file transfers between peers. This is handled entirely within the Go layer before any data transmission occurs.

Does the TypeScript web interface support the same features as the CLI?

The TypeScript client in web/src/protocol/client.ts communicates with the same Go-based relay server as the CLI, but feature parity depends on the specific implementation version. The web interface provides core send/receive functionality through the browser, while advanced options may remain CLI-exclusive.

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