# How Fastfetch Detects Processes on Unix-Like Systems: A Deep Dive into the Source Code

> Discover how fastfetch detects processes on Unix-like systems by exploring its source code. Learn about its platform abstraction layer for Linux, BSD, and OpenBSD.

- Repository: [fastfetch-cli/fastfetch](https://github.com/fastfetch-cli/fastfetch)
- Tags: deep-dive
- Published: 2026-03-30

---

**Fastfetch detects processes on Unix-like systems through a platform abstraction layer in `src/detection/processes/` that uses `/proc` on Linux, `sysctl` on BSD systems, and `kvm` on OpenBSD to count running processes.**

The fastfetch-cli/fastfetch repository implements process detection via a modular architecture that isolates OS-specific kernel interfaces behind a unified C API. This design allows the tool to report accurate process counts across diverse Unix variants while maintaining clean separation between detection logic and presentation layers.

## Platform-Specific Detection Strategies

Fastfetch selects implementation files at compile time using preprocessor guards, ensuring each platform uses its native kernel interface without runtime overhead.

### Linux: Reading the `/proc` Pseudo-Filesystem

On Linux, fastfetch counts processes by enumerating entries in the `/proc` directory. In [`src/detection/processes/processes_linux.c`](https://github.com/fastfetch-cli/fastfetch/blob/main/src/detection/processes/processes_linux.c), the implementation opens `/proc` using `opendir()`, iterates through directory entries with `readdir()`, and counts subdirectories whose names start with a digit—each representing a process ID (PID).

This approach requires no special privileges for basic counting and avoids dependencies on external libraries. The function returns the total count through the `uint32_t *result` parameter defined in the public API.

### BSD Systems: Using `sysctl` with `KERN_PROC`

For FreeBSD and macOS, fastfetch uses the `sysctl` system call to query the kernel process table. The implementation in [`src/detection/processes/processes_bsd.c`](https://github.com/fastfetch-cli/fastfetch/blob/main/src/detection/processes/processes_bsd.c) constructs a Management Information Base (MIB) array containing `CTL_KERN`, `KERN_PROC`, and `KERN_PROC_ALL`.

The code calls `sysctl()` twice: first to determine the required buffer size, then to fetch the array of `kinfo_proc` structures. Dividing the returned buffer length by `sizeof(struct kinfo_proc)` yields the exact process count without parsing text files.

### NetBSD: `KERN_PROC2` and `kinfo_proc2`

NetBSD requires a slightly different approach implemented in [`src/detection/processes/processes_nbsd.c`](https://github.com/fastfetch-cli/fastfetch/blob/main/src/detection/processes/processes_nbsd.c). Instead of `KERN_PROC`, fastfetch uses the `KERN_PROC2` MIB entry and the `kinfo_proc2` structure, which provides additional fields and improved binary stability compared to the legacy interface.

The calculation method remains similar to other BSD systems: query the buffer size, allocate memory, fetch the process array, and compute the count from the structure size.

### OpenBSD: The `kvm` Library

OpenBSD's implementation in [`src/detection/processes/processes_obsd.c`](https://github.com/fastfetch-cli/fastfetch/blob/main/src/detection/processes/processes_obsd.c) utilizes the kernel virtual memory (`kvm`) library for process enumeration. The code calls `kvm_open()` to establish a handle, then `kvm_getprocs()` with the `KERN_PROC_ALL` flag to retrieve a snapshot of all processes.

Unlike the BSD `sysctl` method, `kvm_getprocs()` returns both the process array and the count directly, simplifying the calculation logic while requiring linkage against `-lkvm`.

### Haiku and Unsupported Platforms

Haiku OS uses a dedicated `get_process_info` API implemented in [`src/detection/processes/processes_haiku.c`](https://github.com/fastfetch-cli/fastfetch/blob/main/src/detection/processes/processes_haiku.c), though the specific implementation details are abstracted within the Haiku API. For unsupported platforms, [`src/detection/processes/processes_nosupport.c`](https://github.com/fastfetch-cli/fastfetch/blob/main/src/detection/processes/processes_nosupport.c) provides a fallback that returns a "not supported" error string.

## Architectural Flow: From Module to Kernel

The process detection follows a strict three-layer architecture that separates presentation from platform-specific system calls.

1. **Module Entry**: `ffPrintProcesses()` in [`src/modules/processes/processes.c`](https://github.com/fastfetch-cli/fastfetch/blob/main/src/modules/processes/processes.c) invokes `ffDetectProcesses(&numProcesses)`, passing a pointer to a `uint32_t` variable.

2. **Platform Dispatch**: The build system includes the appropriate platform-specific file (e.g., [`processes_linux.c`](https://github.com/fastfetch-cli/fastfetch/blob/main/processes_linux.c) or [`processes_bsd.c`](https://github.com/fastfetch-cli/fastfetch/blob/main/processes_bsd.c)), each implementing the same `ffDetectProcesses` function signature declared in [`src/detection/processes/processes.h`](https://github.com/fastfetch-cli/fastfetch/blob/main/src/detection/processes/processes.h).

3. **Kernel Interface**: The selected implementation executes its OS-specific counting logic—whether scanning `/proc`, calling `sysctl`, or using `kvm`—and writes the result to the provided pointer.

4. **Output Generation**: Upon successful detection, the module formats the count for display. If the user requested JSON output via `--json`, `ffGenerateProcessesJsonResult()` structures the data under the `"result"` field; otherwise, the raw number prints with the configured formatting.

## Using the Processes Module

You can verify the detection mechanism directly through fastfetch's CLI or programmatically via its C API.

Display the current process count in default format:

```bash
fastfetch --module processes

```

Retrieve structured data for scripting purposes:

```bash
fastfetch --module processes --json

```

The JSON output follows this structure:

```json
{
  "processes": {
    "result": 1234
  }
}

```

To integrate fastfetch's detection into your own C application, include the detection header and call the abstraction function:

```c
#include "detection/processes/processes.h"
#include <stdio.h>

int main(void) {
    uint32_t count;
    const char *err = ffDetectProcesses(&count);
    if (err) {
        fprintf(stderr, "Error detecting processes: %s\n", err);
        return 1;
    }
    printf("Running processes: %u\n", count);
    return 0;
}

```

## Summary

- **Fastfetch** uses [`src/detection/processes/processes.h`](https://github.com/fastfetch-cli/fastfetch/blob/main/src/detection/processes/processes.h) to declare the cross-platform API `ffDetectProcesses(uint32_t *result)`.
- **Linux** implementations scan `/proc` directories, counting numeric PID entries.
- **BSD variants** (FreeBSD, macOS) query the kernel via `sysctl` with `KERN_PROC` MIBs and calculate counts from `kinfo_proc` structure sizes.
- **NetBSD** uses the modern `KERN_PROC2` interface with `kinfo_proc2` structures.
- **OpenBSD** relies on the `kvm` library (`kvm_open`, `kvm_getprocs`) for kernel process table snapshots.
- The **module layer** in [`src/modules/processes/processes.c`](https://github.com/fastfetch-cli/fastfetch/blob/main/src/modules/processes/processes.c) handles formatting and JSON generation, keeping detection logic pure and reusable.

## Frequently Asked Questions

### What function does fastfetch use to detect processes?

Fastfetch declares `const char* ffDetectProcesses(uint32_t *result);` in [`src/detection/processes/processes.h`](https://github.com/fastfetch-cli/fastfetch/blob/main/src/detection/processes/processes.h). This function abstracts all platform-specific implementations, returning an error string if detection fails or writing the process count to the provided `uint32_t` pointer on success.

### How does fastfetch count processes on Linux?

On Linux, fastfetch opens the `/proc` pseudo-filesystem in [`src/detection/processes/processes_linux.c`](https://github.com/fastfetch-cli/fastfetch/blob/main/src/detection/processes/processes_linux.c) and counts directory entries whose names consist entirely of digits. Each numeric entry corresponds to a running process ID, providing an accurate count without requiring system calls or external libraries.

### Why does fastfetch use different methods for BSD and Linux?

Linux exposes process information through the standardized `/proc` virtual filesystem, while BSD systems traditionally use `sysctl` kernel interfaces. OpenBSD specifically deprecates certain `sysctl` process queries in favor of the `kvm` library for security and consistency. Fastfetch adapts to each platform's canonical interface to ensure accurate, privileged-free operation across Unix variants.

### Can I use fastfetch's process detection in my own C program?

Yes. Include [`src/detection/processes/processes.h`](https://github.com/fastfetch-cli/fastfetch/blob/main/src/detection/processes/processes.h) and link against the appropriate platform-specific implementation file (e.g., [`processes_linux.c`](https://github.com/fastfetch-cli/fastfetch/blob/main/processes_linux.c) for Linux systems). The `ffDetectProcesses` function provides a clean, dependency-minimal API for retrieving system process counts without parsing command output yourself.