# What Build Tools Does Bitchat Use? A Complete Guide to the Swift Development Pipeline

> Discover the build tools Bitchat employs: Swift Package Manager, xcodebuild, Just, SwiftLint, and Periphery. Learn about its Swift development pipeline.

- Repository: [permissionlesstech/bitchat](https://github.com/permissionlesstech/bitchat)
- Tags: deep-dive
- Published: 2026-08-06

---

**Bitchat uses Swift Package Manager as its primary dependency manager, Xcode with xcodebuild for native iOS/macOS compilation, and three specialized tools—Just for task automation, SwiftLint for style enforcement, and Periphery for dead-code analysis—coordinated through GitHub Actions CI.**

The Bitchat repository is a native Swift application for iOS and macOS that demonstrates modern Apple ecosystem development practices. This guide examines each build tool used in the project, where it is configured, and how developers interact with it during daily workflows.

## Swift Package Manager: Dependency Management and Compilation

**Swift Package Manager (SPM)** serves as the foundation of Bitchat's build system. It declares Swift modules, library targets, and external dependencies in a single manifest file.

The [`Package.swift`](https://github.com/permissionlesstech/bitchat/blob/main/Package.swift) file at the repository root defines:
- Package metadata and platform requirements
- Internal targets and their dependencies
- External package dependencies fetched from remote repositories
- Build settings for each target

Developers can compile the project directly without Xcode using standard SPM commands:

```bash

# Compile in debug mode (default)

swift build

# Build optimized release binary

swift build -c release

# Run the test suite

swift test

```

SPM integrates seamlessly with Xcode, which detects the package manifest automatically. The `Package.resolved` file locks dependency versions for reproducible builds across environments.

## Xcode and xcodebuild: Native App Bundling

While SPM handles compilation, **Xcode** remains essential for producing the final `.app` bundle. The `bitchat.xcodeproj` directory contains the full Xcode project configuration, with `project.pbxproj` storing build settings, code signing identities, entitlements, and target definitions.

Key files in the Xcode project:

| File | Purpose |
|------|---------|
| `bitchat.xcodeproj/project.pbxproj` | Primary project definition with targets and build phases |
| `Configs/Debug.xcconfig` | Debug build configuration constants |
| `Configs/Release.xcconfig` | Release build configuration |
| `Configs/Local.xcconfig` | Local development overrides |

The `.xcconfig` files inject build-time values such as API endpoints and feature flags. This pattern keeps secrets and environment-specific settings out of version-controlled source code.

Command-line builds using `xcodebuild` enable CI automation without GUI dependencies:

```bash

# Build the iOS app for device

xcodebuild -project bitchat.xcodeproj -scheme Bitchat -destination 'generic/platform=iOS' build

# Archive for App Store distribution

xcodebuild -project bitchat.xcodeproj -scheme Bitchat -configuration Release archive

```

## Just: Task Automation for Developers

**Just** is a command runner that simplifies common development tasks. The `Justfile` at repository root defines named recipes that wrap complex shell sequences into single commands.

View available tasks:

```bash
just

```

Execute a defined task:

```bash

# Example: clean build as defined in the Justfile

just clean-build

```

The Justfile typically encapsulates operations like:
- Cleaning build artifacts across SPM and Xcode
- Regenerating asset catalogs
- Running local test suites
- Preparing release builds

Using Just reduces cognitive load—developers memorize task names rather than verbose command sequences.

## SwiftLint: Enforcing Code Style

**SwiftLint** maintains consistent code style across the codebase. It analyzes Swift source files against rules defined in [`.swiftlint.yml`](https://github.com/permissionlesstech/bitchat/blob/main/.swiftlint.yml) and reports violations.

Run linting locally:

```bash

# Lint all Swift files using project configuration

swiftlint lint --config .swiftlint.yml

# Auto-correct violations where possible

swiftlint --fix --config .swiftlint.yml

```

The [`.swiftlint.yml`](https://github.com/permissionlesstech/bitchat/blob/main/.swiftlint.yml) configuration typically includes:
- Disabled rules (e.g., `trailing_whitespace`)
- Rule customizations (line length limits, identifier naming)
- Excluded directories (generated code, dependencies)
- Custom rule definitions

SwiftLint runs automatically in CI, blocking merges that introduce style violations.

## Periphery: Dead Code Detection

**Periphery** performs static analysis to identify unused declarations—classes, functions, properties, and parameters that contribute to technical debt. Its configuration in [`.periphery.yml`](https://github.com/permissionlesstech/bitchat/blob/main/.periphery.yml) specifies:
- Source directories to scan
- Indexing build targets
- Retention rules for false-positive suppression

Execute dead-code analysis:

```bash
periphery scan --config .periphery.yml

```

Periphery integrates into CI via [`.github/workflows/periphery.yml`](https://github.com/permissionlesstech/bitchat/blob/main/.github/workflows/periphery.yml), running on each pull request to prevent unused code accumulation.

## GitHub Actions: Continuous Integration Orchestration

**GitHub Actions** coordinates the complete build pipeline. The `.github/workflows` directory contains workflow definitions that automate validation on every push and pull request.

Primary workflows:

| Workflow file | Responsibility |
|-------------|--------------|
| [`swift-tests.yml`](https://github.com/permissionlesstech/bitchat/blob/main/swift-tests.yml) | Builds the package and runs unit tests |
| [`periphery.yml`](https://github.com/permissionlesstech/bitchat/blob/main/periphery.yml) | Executes dead-code analysis |
| [`fetch_georelays.yml`](https://github.com/permissionlesstech/bitchat/blob/main/fetch_georelays.yml) | Updates relay metadata (operational task) |

The [`swift-tests.yml`](https://github.com/permissionlesstech/bitchat/blob/main/swift-tests.yml) workflow typically:
1. Checks out source code
2. Selects Xcode version matching project requirements
3. Resolves SPM dependencies
4. Builds targets with `swift build` or `xcodebuild`
5. Executes test suite with `swift test` or `xcodebuild test`
6. Archives build artifacts on failure for debugging

## Build Tool Configuration Summary

| Tool | Config File | Primary Function |
|------|-------------|------------------|
| Swift Package Manager | [`Package.swift`](https://github.com/permissionlesstech/bitchat/blob/main/Package.swift) | Dependency resolution and compilation |
| Xcode | `bitchat.xcodeproj/project.pbxproj` | Native app bundling and signing |
| Just | `Justfile` | Developer task automation |
| SwiftLint | [`.swiftlint.yml`](https://github.com/permissionlesstech/bitchat/blob/main/.swiftlint.yml) | Style enforcement |
| Periphery | [`.periphery.yml`](https://github.com/permissionlesstech/bitchat/blob/main/.periphery.yml) | Dead code detection |
| Xcode Config | `Configs/*.xcconfig` | Build-time constants |

## Summary

- **Swift Package Manager** in [`Package.swift`](https://github.com/permissionlesstech/bitchat/blob/main/Package.swift) manages dependencies and provides cross-platform compilation via `swift build`.
- **Xcode and xcodebuild** create signed `.app` bundles for iOS/macOS distribution, configured through `bitchat.xcodeproj` and `.xcconfig` files.
- **Just** automates repetitive commands through recipes defined in `Justfile`.
- **SwiftLint** enforces style rules from [`.swiftlint.yml`](https://github.com/permissionlesstech/bitchat/blob/main/.swiftlint.yml), catching issues before merge.
- **Periphery** scans for unused code using [`.periphery.yml`](https://github.com/permissionlesstech/bitchat/blob/main/.periphery.yml), maintaining codebase health.
- **GitHub Actions** workflows in `.github/workflows/` orchestrate CI validation across all tools.

## Frequently Asked Questions

### Can Bitchat be built without Xcode?

Yes. The Swift Package Manager enables command-line compilation with `swift build` and testing with `swift test`. However, producing a signed iOS/macOS application bundle requires Xcode or `xcodebuild` for code signing, entitlements, and app packaging.

### How do I run the same checks that CI performs?

Execute the core validation steps locally: `swift build` to compile, `swift test` to run tests, `swiftlint lint` for style checking, and `periphery scan` for dead-code detection. The `Justfile` likely provides a combined task for convenience.

### What is the purpose of the .xcconfig files?

The `Configs/Debug.xcconfig`, `Release.xcconfig`, and `Local.xcconfig` files store build-time constants that vary by environment. This pattern keeps API endpoints, feature flags, and secrets out of source code while allowing Xcode to inject them during compilation.

### Is SwiftLint required for contributions?

Yes. The [`swift-tests.yml`](https://github.com/permissionlesstech/bitchat/blob/main/swift-tests.yml) workflow runs SwiftLint in CI and will fail builds that violate configured rules. Run `swiftlint lint --config .swiftlint.yml` before committing, or use `swiftlint --fix` to auto-correct eligible violations.