# Development Tools Used with Superfile: Complete Technical Stack Guide

> Explore the technical stack behind Superfile. Discover development tools including Go, Make, Bash, Astro, pnpm, Python, and GitHub Actions for building, documenting, and testing.

- Repository: [Yorukot/superfile](https://github.com/yorukot/superfile)
- Tags: best-practices
- Published: 2026-07-29

---

**Superfile relies on a multi-language toolchain centered on Go 1.26 for the core application, Make and Bash for build automation, Astro with pnpm for its documentation site, and Python with GitHub Actions for integration testing and Windows releases.**

Superfile is a Go-native terminal file manager that ships with a modern web-based documentation portal. Understanding the development tools used with Superfile is essential for contributors compiling from source, running the full test matrix, or extending the project's documentation. The repository orchestrates these disparate technologies through a central `Makefile` and a Bash-based [`dev.sh`](https://github.com/yorukot/superfile/blob/main/dev.sh) wrapper script that unifies the entire workflow.

## Core Go Development Toolchain

The foundation of Superfile is built on **Go 1.26**, as declared in the root `go.mod` file. This version pin ensures consistent compilation across development environments and CI pipelines.

### Module Management and Static Analysis

Dependency management follows standard Go conventions using `go mod tidy` and `go get`, while code quality is enforced by **golangci-lint**. According to the source code in `Makefile` at line 18, the `lint` target invokes this linter to scan the entire Go codebase for potential issues.

```bash

# Run only the linter

make lint

```

The toolchain also enforces formatting standards via `go fmt`, which is automatically invoked during the development workflow to ensure consistent code style before compilation.

### Build Automation with Make

The `Makefile` at the repository root serves as the central orchestration layer, defining concrete targets for every phase of development:

- **`make dev`** – Runs the full development cycle (tidy, format, lint, test, build)
- **`make build`** – Compiles the `spf` binary
- **`make test`** – Executes `go test ./...` across all packages
- **`make testsuite`** – Triggers the Python-based integration tests
- **`make clean`** – Removes build artifacts

## Development Workflow Automation

Superfile provides a **Bash wrapper script** ([`dev.sh`](https://github.com/yorukot/superfile/blob/main/dev.sh)) that glues together the discrete steps of the Go toolchain. This script automates the sequence of `go mod tidy`, `go fmt`, golangci-lint execution, unit tests, optional Python integration test execution, and final binary compilation.

Running the complete workflow is executed via:

```bash

# Invokes dev.sh through Make

make dev

```

This automation ensures that contributors cannot accidentally commit unformatted code or skip linting checks before the binary is generated.

## Documentation Website Stack

The project maintains a static documentation site powered by **Astro v6** and managed with **pnpm v10**, as specified in [`website/package.json`](https://github.com/yorukot/superfile/blob/main/website/package.json).

### Front-End Tooling

The documentation layer employs a modern Node.js ecosystem:

- **Astro** – Static site generator for the documentation portal
- **Tailwind CSS** – Utility-first styling framework
- **GSAP** – Animation library for interactive documentation elements
- **Prettier** – Code formatter for consistent front-end asset styling

### Content Management and Search

Advanced Markdown capabilities come through **`@astrojs/mdx`**, **`remark-directive`**, and **`unist-util-visit`**, enabling custom directives within documentation files. For client-side search functionality, the build process integrates **pagefind** to generate a searchable index of all documentation content.

Local development of the documentation requires:

```bash
cd website
pnpm install           # Installs Astro and related dependencies

pnpm run dev           # Starts live-reload development server

pnpm run build         # Outputs static site to dist/ directory

```

## Python-Based Integration Testing

While the core application is Go-based, the end-to-end integration testsuite relies on **Python 3** and a dedicated virtual environment. The [`testsuite/requirements.txt`](https://github.com/yorukot/superfile/blob/main/testsuite/requirements.txt) file declares dependencies including `pyautogui`, `libtmux`, `pyperclip`, and `assertpy`.

These tools enable automated terminal interaction testing, allowing the testsuite to simulate user input in tmux sessions, manipulate the clipboard, and assert on application state. The [`dev.sh`](https://github.com/yorukot/superfile/blob/main/dev.sh) script optionally activates this Python environment and executes the integration tests when running the full development workflow.

Trigger the Python testsuite independently via:

```bash
make testsuite

```

## CI/CD and Release Automation

Release management for Windows packages is handled through **GitHub Actions**, specifically the workflow defined in [`.github/workflows/winget.yml`](https://github.com/yorukot/superfile/blob/main/.github/workflows/winget.yml). This configuration automatically publishes the compiled binary to the WinGet community repository whenever a new GitHub release is created.

For manual invocation of this CI step (requires `WINGET_TOKEN` environment variable):

```bash
gh workflow run winget.yml

```

## Summary

- **Go 1.26** powers the core application with `go.mod` managing dependencies.
- **golangci-lint** and `go fmt` enforce code quality via `Makefile` targets.
- **[`dev.sh`](https://github.com/yorukot/superfile/blob/main/dev.sh)** automates the complete development cycle from module tidying to binary compilation.
- **Astro v6** and **pnpm** generate the documentation site with **pagefind** for search and **Tailwind/GSAP** for styling.
- **Python 3** with `pyautogui` and `libtmux` drives the end-to-end integration testsuite.
- **GitHub Actions** ([`winget.yml`](https://github.com/yorukot/superfile/blob/main/winget.yml)) handles automated Windows package distribution.

## Frequently Asked Questions

### What version of Go is required to build Superfile?

Superfile requires **Go 1.26**, as specified in the `go.mod` file located at the repository root. This version ensures compatibility with the module dependencies and build directives defined in the `Makefile`.

### Why does Superfile use Python for testing if it's written in Go?

The project uses **Python** for integration testing because the `testsuite` leverages libraries like `pyautogui` and `libtmux` to simulate real terminal interactions and tmux sessions. These Python tools can automate end-to-end user scenarios that are difficult to replicate with Go's native testing framework alone.

### Which static site generator powers the Superfile documentation?

The documentation site is built with **Astro v6**, managed through **pnpm v10**. The stack includes **Tailwind CSS** for styling, **GSAP** for animations, and **pagefind** for client-side search functionality, as detailed in [`website/package.json`](https://github.com/yorukot/superfile/blob/main/website/package.json).

### How does the [`dev.sh`](https://github.com/yorukot/superfile/blob/main/dev.sh) script differ from using `make` commands directly?

The **[`dev.sh`](https://github.com/yorukot/superfile/blob/main/dev.sh)** Bash script wraps and sequences multiple `make` targets and Go commands (including `go mod tidy`, `go fmt`, and optional Python testsuite execution) into a single automated workflow. While `make` handles individual build steps, [`dev.sh`](https://github.com/yorukot/superfile/blob/main/dev.sh) ensures they execute in the correct order with proper error handling between stages.