refactor: rename all 'allocator' args to 'gpa'

Feat linux/packages

.github/workflows/build.yml

@@ -2,11 +2,12 @@ name: Build
 
 on:
   push:
-    branches: [ "main" ]
+    branches: ["main"]
     paths:
-      - 'src/**'
+      - ".github/workflows/build.yml"
-      - 'build.zig'
+      - "src/**"
-      - 'build.zig.zon'
+      - "build.zig"
+      - "build.zig.zon"
 
 jobs:
   build:
@@ -22,7 +23,7 @@ jobs:
               sudo apt-get install -y libpci-dev
 
           # macOS x86_64
-          - os: macos-13
+          - os: macos-15
             target: x86_64-darwin
             runner_arch: x64
             setup_deps: ""
@@ -36,64 +37,64 @@ jobs:
     runs-on: ${{ matrix.os }}
 
     steps:
-    - name: Checkout code
+      - name: Checkout code
-      uses: actions/checkout@v4
+        uses: actions/checkout@v4
 
-    - name: Setup Zig
+      - name: Setup Zig
-      uses: mlugg/setup-zig@v2
+        uses: mlugg/setup-zig@v2
-      with:
+        with:
-        version: 0.15.1
+          version: 0.15.2
 
-    - name: Setup platform dependencies
+      - name: Setup platform dependencies
-      if: matrix.setup_deps != ''
+        if: matrix.setup_deps != ''
-      run: ${{ matrix.setup_deps }}
+        run: ${{ matrix.setup_deps }}
 
-    - name: Cache Zig
+      - name: Cache Zig
-      uses: actions/cache@v4
+        uses: actions/cache@v4
-      with:
+        with:
-        path: |
+          path: |
-          ~/.cache/zig
+            ~/.cache/zig
-          zig-cache
+            zig-cache
-        key: ${{ runner.os }}-${{ matrix.target }}-zig-${{ hashFiles('build.zig', 'build.zig.zon') }}
+          key: ${{ runner.os }}-${{ matrix.target }}-zig-${{ hashFiles('build.zig', 'build.zig.zon') }}
-        restore-keys: |
+          restore-keys: |
-          ${{ runner.os }}-${{ matrix.target }}-zig-
+            ${{ runner.os }}-${{ matrix.target }}-zig-
 
-    - name: Build for target
+      - name: Build for target
-      run: |
+        run: |
-        zig build -Doptimize=ReleaseSafe
+          zig build -Doptimize=ReleaseSafe
 
-        mv zig-out/bin/zigfetch zig-out/bin/zigfetch-${{ matrix.target }}
+          mv zig-out/bin/zigfetch zig-out/bin/zigfetch-${{ matrix.target }}
 
-    - name: Verify binary
+      - name: Verify binary
-      run: |
+        run: |
-        ls -la zig-out/bin/
+          ls -la zig-out/bin/
-        file zig-out/bin/zigfetch-${{ matrix.target }}
+          file zig-out/bin/zigfetch-${{ matrix.target }}
 
-    - name: Upload artifacts
+      - name: Upload artifacts
-      uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v4
-      with:
+        with:
-        name: zigfetch-${{ matrix.target }}
+          name: zigfetch-${{ matrix.target }}
-        path: zig-out/bin/zigfetch-${{ matrix.target }}
+          path: zig-out/bin/zigfetch-${{ matrix.target }}
-        retention-days: 3
+          retention-days: 3
 
   test:
     runs-on: ubuntu-latest
 
     steps:
-    - name: Checkout code
+      - name: Checkout code
-      uses: actions/checkout@v4
+        uses: actions/checkout@v4
 
-    - name: Setup Zig
+      - name: Setup Zig
-      uses: mlugg/setup-zig@v2
+        uses: mlugg/setup-zig@v2
-      with:
+        with:
-        version: 0.15.1
+          version: 0.15.1
 
-    - name: Setup dependencies
+      - name: Setup dependencies
-      run: |
+        run: |
-        sudo apt-get update
+          sudo apt-get update
-        sudo apt-get install -y libpci-dev
+          sudo apt-get install -y libpci-dev
 
-    - name: Run tests
+      - name: Run tests
-      run: |
+        run: |
-        zig test src/ascii.zig
+          zig test src/ascii.zig
-        zig test src/utils.zig
+          zig test src/utils.zig

.gitignore

@@ -1 +1,3 @@
 *zig-*
+result
+.tool-versions

README.md

@@ -13,13 +13,13 @@
 
 ---
 
--   [Description](#description)
+- [Description](#description)
--   [Requirements](#requirements)
+- [Requirements](#requirements)
--   [Installation](#installation)
+- [Installation](#installation)
--   [Usage](#usage)
+- [Usage](#usage)
-    -   [Configuration](#configuration)
+  - [Configuration](#configuration)
--   [Roadtrip](#roadtrip)
+- [Roadtrip](#roadtrip)
--   [Contributing](#contributing)
+- [Contributing](#contributing)
 
 ## Description
 
@@ -27,17 +27,17 @@ Zigfetch is a minimal [neofetch](https://github.com/dylanaraps/neofetch)/[fastfe
 
 ## Requirements
 
--   \>= [zig v0.15.2](https://ziglang.org/)
+- \>= [zig v0.15.2](https://ziglang.org/)
 
 ### Linux only
 
--   [libpci](https://github.com/pciutils/pciutils)
+- [libpci](https://github.com/pciutils/pciutils)
 
 ## Installation
 
 ### Build from source
 
-```console
+```bash
 # Clone the repo
 $ git clone https://github.com/utox39/zigfetch.git
 
@@ -53,14 +53,20 @@ $ mv ./zig-out/zigfetch ~/bin/
 
 ### Via [Homebrew](https://brew.sh/)
 
-```console
+```bash
-$ brew install utox39/tap/zigfetch
+brew install utox39/tap/zigfetch
 ```
 
+### Other package managers
+
+[![Packaging status](https://repology.org/badge/vertical-allrepos/zigfetch.svg)](https://repology.org/project/zigfetch/versions)
+
+- nixpkg: Thanks to [@heisfer](https://github.com/heisfer)
+
 ## Usage
 
-```console
+```bash
-$ zigfetch
+zigfetch
 ```
 
 ### Configuration
@@ -68,51 +74,51 @@ $ zigfetch
 > [!IMPORTANT]
 > Currently, Zig does not have a built-in library for JSON validation via JSON schema, so it is very important to follow the pattern shown in the default configuration file ([config.json](https://github.com/utox39/zigfetch/blob/main/config.json)) to avoid errors
 
--   Create the config folder
+- Create the config folder
 
-```console
+```bash
-$ mkdir -p ~/.config/zigfetch
+mkdir -p ~/.config/zigfetch
 ```
 
--   Create the config file
+- Create the config file
 
-```console
+```bash
-$ cd ~/.config/zigfetch
+cd ~/.config/zigfetch
-$ touch config.json
+touch config.json
 ```
 
--   Or copy the default config (preferred way)
+- Or copy the default config (preferred way)
 
-```console
+```bash
-$ cp /path/to/zigfetch/config.json ~/.config/zigfetch/config.json
+cp /path/to/zigfetch/config.json ~/.config/zigfetch/config.json
 ```
 
 #### Modules
 
 Available modules:
 
--   Os
+- Os
--   Kernel
+- Kernel
--   Uptime
+- Uptime
--   Packages
+- Packages
--   Shell
+- Shell
--   Cpu
+- Cpu
--   Gpu
+- Gpu
--   Ram
+- Ram
--   Swap
+- Swap
--   Disk
+- Disk
--   Net
+- Net
--   WM (Window Manager)
+- WM (Window Manager)
--   Terminal
+- Terminal
--   Locale
+- Locale
--   Custom
+- Custom
 
 | Module type |      Linux      |          macOS           | Windows |
 | :---------: | :-------------: | :----------------------: | :-----: |
 |     os      |       Yes       |           Yes            |   WIP   |
 |   kernel    |       Yes       |           Yes            |   WIP   |
 |   uptime    |       Yes       |           Yes            |   WIP   |
-|  packages   |       WIP       | Yes (Homebrew, Macports) |   WIP   |
+|  packages   |       Yes*      | Yes (Homebrew, Macports) |   WIP   |
 |    shell    | Yes (bash, zsh) |     Yes (bash, zsh)      |   WIP   |
 |     cpu     |       Yes       |           Yes            |   WIP   |
 |     gpu     |       Yes       | Yes (Apple Silicon only) |   WIP   |
@@ -124,6 +130,8 @@ Available modules:
 |  terminal   |       Yes       |           Yes            |   WIP   |
 |   locale    |       Yes       |           Yes            |   WIP   |
 
+\*(flatpak, nix, dpkg, pacman, xbps)
+
 ```json
   "modules": [
     {
@@ -168,11 +176,11 @@ To change the Username and Hostname color (HEX colors only):
 
 ## Roadtrip
 
--   [ ] Add ASCII art for each operating system and Linux distro
+- [ ] Add ASCII art for each operating system and Linux distro
--   [x] Add GPU info for Linux
+- [x] Add GPU info for Linux
--   [ ] Add packages info for Linux
+- [x] Add packages info for Linux
--   [x] Add user customization
+- [x] Add user customization
--   [ ] Add support for Windows
+- [ ] Add support for Windows
 
 ## Contributing
 

build.zig

@@ -25,13 +25,11 @@ pub fn build(b: *std.Build) void {
     });
 
     if (target.result.os.tag == .macos) {
-        exe.linkFramework("CoreFoundation");
+        exe.root_module.linkFramework("CoreFoundation", .{ .needed = true });
-        exe.linkFramework("IOKit");
+        exe.root_module.linkFramework("IOKit", .{ .needed = true });
-    }
+    } else if (target.result.os.tag == .linux) {
-
+        exe.root_module.link_libc = true;
-    if (target.result.os.tag == .linux) {
+        exe.root_module.linkSystemLibrary("pci", .{ .needed = true });
-        exe.linkLibC();
-        exe.linkSystemLibrary("pci");
     }
 
     // This declares intent for the executable to be installed into the

build.zig.zon

@@ -10,7 +10,7 @@
 
     // This is a [Semantic Version](https://semver.org/).
     // In a future version of Zig it will be used for package deduplication.
-    .version = "0.24.2",
+    .version = "0.25.0",
 
     // Together with name, this represents a globally unique package
     // identifier. This field is generated by the Zig toolchain when the

default.nix

@@ -0,0 +1,20 @@
+{ pkgs ? import <nixpkgs> {} }:
+
+pkgs.stdenv.mkDerivation {
+  pname = "zigfetch";
+  version = "0.25.0";
+
+  src = ./.;
+
+  nativeBuildInputs = with pkgs; [
+    zig.hook
+  ];
+
+  buildInputs = with pkgs; [
+    pciutils
+  ];
+
+  zigBuildFlags = [
+    "-Doptimize=ReleaseSafe"
+  ];
+}

shell.nix

@@ -0,0 +1,13 @@
+{ pkgs ? import <nixpkgs> {} }:
+
+let
+  unstable = import (builtins.fetchTarball {
+    url = "https://github.com/NixOS/nixpkgs/archive/nixos-unstable.tar.gz";
+  }) {};
+in
+pkgs.mkShell {
+  buildInputs = [
+    unstable.zig
+    pkgs.pciutils
+  ];
+}

src/config.zig

@@ -1,5 +1,5 @@
 const std = @import("std");
-const ascii = @import("ascii.zig");
+const display = @import("display.zig");
 const utils = @import("utils.zig");
 
 pub const Module = struct {
@@ -44,8 +44,8 @@ pub fn getUsernameHostnameColor(config: ?std.json.Parsed(Config)) ?[]u8 {
     } else return null;
 }
 
-pub fn getModulesTypes(allocator: std.mem.Allocator, config: ?std.json.Parsed(Config)) !std.array_list.Managed(ModuleType) {
+pub fn getModulesTypes(gpa: std.mem.Allocator, config: ?std.json.Parsed(Config)) !std.array_list.Managed(ModuleType) {
-    var modules_list = std.array_list.Managed(ModuleType).init(allocator);
+    var modules_list = std.array_list.Managed(ModuleType).init(gpa);
 
     if (config) |c| {
         for (c.value.modules) |module| {
@@ -62,23 +62,23 @@ pub fn getModulesTypes(allocator: std.mem.Allocator, config: ?std.json.Parsed(Co
     return modules_list;
 }
 
-pub fn readConfigFile(allocator: std.mem.Allocator) !?std.json.Parsed(Config) {
+pub fn readConfigFile(gpa: std.mem.Allocator, io: std.Io, environ: std.process.Environ) !?std.json.Parsed(Config) {
-    const home = try std.process.getEnvVarOwned(allocator, "HOME");
+    const home = try std.process.Environ.getAlloc(environ, gpa, "HOME");
-    defer allocator.free(home);
+    defer gpa.free(home);
 
-    const config_abs_path = try std.mem.concat(allocator, u8, &.{ home, "/.config/zigfetch/config.json" });
+    const config_abs_path = try std.mem.concat(gpa, u8, &.{ home, "/.config/zigfetch/config.json" });
-    defer allocator.free(config_abs_path);
+    defer gpa.free(config_abs_path);
 
-    const config_file = std.fs.openFileAbsolute(config_abs_path, .{ .mode = .read_only }) catch |err| switch (err) {
+    const config_file = std.Io.Dir.openFileAbsolute(io, config_abs_path, .{ .mode = .read_only }) catch |err| switch (err) {
         error.FileNotFound => return null,
         else => return err,
     };
-    defer config_file.close();
+    defer config_file.close(io);
 
-    const file_size = (try config_file.stat()).size;
+    const file_size = (try config_file.stat(io)).size;
 
-    const config_data = try utils.readFile(allocator, config_file, file_size);
+    const config_data = try utils.readFile(gpa, io, config_file, file_size);
-    defer allocator.free(config_data);
+    defer gpa.free(config_data);
 
-    return try std.json.parseFromSlice(Config, allocator, config_data, .{ .allocate = .alloc_always });
+    return try std.json.parseFromSlice(Config, gpa, config_data, .{ .allocate = .alloc_always });
 }

src/display.zig

@@ -65,28 +65,28 @@ test "parse ffffff" {
     try std.testing.expect((result.r == 255) and (result.g == 255) and (result.b == 255));
 }
 
-pub fn printAsciiAndModules(allocator: std.mem.Allocator, ascii_art_path: ?[]u8, sys_info_list: std.array_list.Managed([]u8)) !void {
+pub fn printAsciiAndModules(gpa: std.mem.Allocator, io: std.Io, ascii_art_path: ?[]u8, sys_info_list: std.array_list.Managed([]u8)) !void {
     var stdout_buffer: [2048]u8 = undefined;
-    var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
+    var stdout_file_writer: std.Io.File.Writer = .init(.stdout(), io, &stdout_buffer);
-    const stdout = &stdout_writer.interface;
+    const stdout = &stdout_file_writer.interface;
 
     var ascii_art_data: []const u8 = undefined;
     if (ascii_art_path) |ascii| {
-        const ascii_file = try std.fs.cwd().openFile(ascii, .{ .mode = .read_only });
+        const ascii_file = try std.Io.Dir.cwd().openFile(io, ascii, .{ .mode = .read_only });
-        defer ascii_file.close();
+        defer ascii_file.close(io);
-        const file_size = (try ascii_file.stat()).size;
+        const file_size = (try ascii_file.stat(io)).size;
-        ascii_art_data = try utils.readFile(allocator, ascii_file, file_size);
+        ascii_art_data = try utils.readFile(gpa, io, ascii_file, file_size);
     } else {
         ascii_art_data = @embedFile("./assets/ascii/guy_fawks.txt");
     }
 
     defer if (ascii_art_path != null) {
-        allocator.free(ascii_art_data);
+        gpa.free(ascii_art_data);
     };
 
     var lines = std.mem.splitScalar(u8, ascii_art_data, '\n');
 
-    var ascii_art_content_list = std.array_list.Managed([]const u8).init(allocator);
+    var ascii_art_content_list = std.array_list.Managed([]const u8).init(gpa);
     defer ascii_art_content_list.deinit();
 
     while (lines.next()) |line| {
@@ -116,7 +116,7 @@ pub fn printAsciiAndModules(allocator: std.mem.Allocator, ascii_art_path: ?[]u8,
     while (i < max_len) : (i += 1) {
         // Print the ascii art if the width of the terminal is greater than the spacing (5) + the longest ascii art row length + the longest sys info string length
         if (can_print_ascii_art) {
-            const alignment_buffer = try allocator.alloc(u8, if (i < ascii_art_len) longest_ascii_art_row_len - (try utils.countCodepoints(ascii_art_items[i])) + spacing else longest_ascii_art_row_len + spacing);
+            const alignment_buffer = try gpa.alloc(u8, if (i < ascii_art_len) longest_ascii_art_row_len - (try utils.countCodepoints(ascii_art_items[i])) + spacing else longest_ascii_art_row_len + spacing);
             @memset(alignment_buffer, ' ');
 
             if (i < ascii_art_len) {
@@ -125,7 +125,7 @@ pub fn printAsciiAndModules(allocator: std.mem.Allocator, ascii_art_path: ?[]u8,
                 try stdout.print("{s}", .{alignment_buffer});
             }
 
-            allocator.free(alignment_buffer);
+            gpa.free(alignment_buffer);
 
             try stdout.flush();
         }
@@ -151,6 +151,6 @@ pub fn printAsciiAndModules(allocator: std.mem.Allocator, ascii_art_path: ?[]u8,
     }
 
     for (sys_info_list.items) |item| {
-        allocator.free(item);
+        gpa.free(item);
     }
 }

src/formatters.zig

@@ -1,6 +1,6 @@
 const builtin = @import("builtin");
 const std = @import("std");
-const ascii = @import("ascii.zig");
+const display = @import("display.zig");
 const detection = @import("detection.zig").os_module;
 
 const Result = union(enum) {
@@ -8,7 +8,13 @@ const Result = union(enum) {
     string_arraylist: std.array_list.Managed([]u8),
 };
 
-pub const formatters = [_]*const fn (allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) anyerror!Result{
+pub const FormatterContext = struct {
+    gpa: std.mem.Allocator,
+    io: std.Io,
+    environ: std.process.Environ,
+};
+
+pub const formatters = [_]*const fn (fmt_ctx: FormatterContext, key: []const u8, key_color: []const u8) anyerror!Result{
     &getFormattedOsInfo,
     &getFormattedKernelInfo,
     &getFormattedUptimeInfo,
@@ -26,7 +32,7 @@ pub const formatters = [_]*const fn (allocator: std.mem.Allocator, key: []const
     &getFormattedCustom,
 };
 
-pub const default_formatters = [_]*const fn (allocator: std.mem.Allocator) anyerror!Result{
+pub const default_formatters = [_]*const fn (fmt_ctx: FormatterContext) anyerror!Result{
     &getDefaultFormattedOsInfo,
     &getDefaultFormattedKernelInfo,
     &getDefaultFormattedUptimeInfo,
@@ -43,105 +49,168 @@ pub const default_formatters = [_]*const fn (allocator: std.mem.Allocator) anyer
     &getDefaultFormattedLocaleInfo,
 };
 
-pub fn getFormattedUsernameHostname(allocator: std.mem.Allocator, color: []const u8, username: []const u8, hostname: []const u8) ![]u8 {
+pub fn getFormattedUsernameHostname(gpa: std.mem.Allocator, color: []const u8, username: []const u8, hostname: []const u8) ![]u8 {
-    return try std.fmt.allocPrint(allocator, "{s}{s}{s}@{s}{s}{s}", .{
+    return try std.fmt.allocPrint(gpa, "{s}{s}{s}@{s}{s}{s}", .{
         color,
         username,
-        ascii.Reset,
+        display.Reset,
         color,
         hostname,
-        ascii.Reset,
+        display.Reset,
     });
 }
 
-pub fn getDefaultFormattedKernelInfo(allocator: std.mem.Allocator) !Result {
+pub fn getDefaultFormattedKernelInfo(fmt_ctx: FormatterContext) !Result {
-    return try getFormattedKernelInfo(allocator, "Kernel", ascii.Yellow);
+    return try getFormattedKernelInfo(fmt_ctx, "Kernel", display.Yellow);
 }
 
-pub fn getFormattedKernelInfo(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) !Result {
+pub fn getFormattedKernelInfo(fmt_ctx: FormatterContext, key: []const u8, key_color: []const u8) !Result {
+    const allocator = fmt_ctx.gpa;
+
     const kernel_info = try detection.system.getKernelInfo(allocator);
     defer allocator.free(kernel_info.kernel_name);
     defer allocator.free(kernel_info.kernel_release);
 
-    return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}:{s} {s} {s}", .{ key_color, key, ascii.Reset, kernel_info.kernel_name, kernel_info.kernel_release }) };
+    return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}:{s} {s} {s}", .{
+        key_color,
+        key,
+        display.Reset,
+        kernel_info.kernel_name,
+        kernel_info.kernel_release,
+    }) };
 }
 
-pub fn getDefaultFormattedOsInfo(allocator: std.mem.Allocator) !Result {
+pub fn getDefaultFormattedOsInfo(fmt_ctx: FormatterContext) !Result {
-    return try getFormattedOsInfo(allocator, "OS", ascii.Yellow);
+    return try getFormattedOsInfo(fmt_ctx, "OS", display.Yellow);
 }
 
-pub fn getFormattedOsInfo(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) !Result {
+pub fn getFormattedOsInfo(fmt_ctx: FormatterContext, key: []const u8, key_color: []const u8) !Result {
-    const os_info = try detection.system.getOsInfo(allocator);
+    const allocator = fmt_ctx.gpa;
+    const io = fmt_ctx.io;
+
+    const os_info = if (builtin.os.tag == .macos) try detection.system.getOsInfo(allocator) else if (builtin.os.tag == .linux) try detection.system.getOsInfo(allocator, io);
     defer allocator.free(os_info);
-    return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}:{s} {s}", .{ key_color, key, ascii.Reset, os_info }) };
+    return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}:{s} {s}", .{
+        key_color,
+        key,
+        display.Reset,
+        os_info,
+    }) };
 }
 
-pub fn getDefaultFormattedLocaleInfo(allocator: std.mem.Allocator) !Result {
+pub fn getDefaultFormattedLocaleInfo(fmt_ctx: FormatterContext) !Result {
-    return try getFormattedLocaleInfo(allocator, "Locale", ascii.Yellow);
+    return try getFormattedLocaleInfo(fmt_ctx, "Locale", display.Yellow);
 }
 
-pub fn getFormattedLocaleInfo(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) !Result {
+pub fn getFormattedLocaleInfo(fmt_ctx: FormatterContext, key: []const u8, key_color: []const u8) !Result {
-    const locale = try detection.system.getLocale(allocator);
+    const allocator = fmt_ctx.gpa;
+    const environ = fmt_ctx.environ;
+
+    const locale = try detection.system.getLocale(allocator, environ);
     defer allocator.free(locale);
-    return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}:{s} {s}", .{ key_color, key, ascii.Reset, locale }) };
+    return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}:{s} {s}", .{
+        key_color,
+        key,
+        display.Reset,
+        locale,
+    }) };
 }
 
-pub fn getDefaultFormattedUptimeInfo(allocator: std.mem.Allocator) !Result {
+pub fn getDefaultFormattedUptimeInfo(fmt_ctx: FormatterContext) !Result {
-    return try getFormattedUptimeInfo(allocator, "Uptime", ascii.Yellow);
+    return try getFormattedUptimeInfo(fmt_ctx, "Uptime", display.Yellow);
 }
 
-pub fn getFormattedUptimeInfo(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) !Result {
+pub fn getFormattedUptimeInfo(fmt_ctx: FormatterContext, key: []const u8, key_color: []const u8) !Result {
-    const uptime = try detection.system.getSystemUptime();
+    const allocator = fmt_ctx.gpa;
-    return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}:{s} {} days, {} hours, {} minutes", .{ key_color, key, ascii.Reset, uptime.days, uptime.hours, uptime.minutes }) };
+    const io = fmt_ctx.io;
+
+    const uptime = if (builtin.os.tag == .macos) try detection.system.getSystemUptime(io) else if (builtin.os.tag == .linux) try detection.system.getSystemUptime();
+    return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}:{s} {} days, {} hours, {} minutes", .{
+        key_color,
+        key,
+        display.Reset,
+        uptime.days,
+        uptime.hours,
+        uptime.minutes,
+    }) };
 }
 
-pub fn getDefaultFormattedPackagesInfo(allocator: std.mem.Allocator) !Result {
+pub fn getDefaultFormattedPackagesInfo(fmt_ctx: FormatterContext) !Result {
-    return try getFormattedPackagesInfo(allocator, "Packages", ascii.Yellow);
+    return try getFormattedPackagesInfo(fmt_ctx, "Packages", display.Yellow);
 }
 
-pub fn getFormattedPackagesInfo(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) !Result {
+pub fn getFormattedPackagesInfo(fmt_ctx: FormatterContext, key: []const u8, key_color: []const u8) !Result {
-    if (builtin.os.tag == .macos) {
+    const allocator = fmt_ctx.gpa;
-        const packages_info = try detection.packages.getPackagesInfo(allocator);
+    const io = fmt_ctx.io;
-        defer allocator.free(packages_info);
+    const environ = fmt_ctx.environ;
-        return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}:{s}{s}", .{ key_color, key, ascii.Reset, packages_info }) };
+
-    } else if (builtin.os.tag == .linux) {
+    const packages_info = if (builtin.os.tag == .macos) try detection.packages.getPackagesInfo(allocator, io) else if (builtin.os.tag == .linux) try detection.packages.getPackagesInfo(allocator, io, environ);
-        return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}:{s} WIP", .{ key_color, key, ascii.Reset }) };
+    defer allocator.free(packages_info);
-    }
+    return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}:{s}{s}", .{
+        key_color,
+        key,
+        display.Reset,
+        packages_info,
+    }) };
 }
 
-pub fn getDefaultFormattedShellInfo(allocator: std.mem.Allocator) !Result {
+pub fn getDefaultFormattedShellInfo(fmt_ctx: FormatterContext) !Result {
-    return try getFormattedShellInfo(allocator, "Shell", ascii.Yellow);
+    return try getFormattedShellInfo(fmt_ctx, "Shell", display.Yellow);
 }
 
-pub fn getFormattedShellInfo(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) !Result {
+pub fn getFormattedShellInfo(fmt_ctx: FormatterContext, key: []const u8, key_color: []const u8) !Result {
-    const shell = try detection.user.getShell(allocator);
+    const allocator = fmt_ctx.gpa;
+    const io = fmt_ctx.io;
+    const environ = fmt_ctx.environ;
+
+    const shell = try detection.user.getShell(allocator, io, environ);
     defer allocator.free(shell);
-    return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}:{s} {s}", .{ key_color, key, ascii.Reset, shell[0..(shell.len - 1)] }) };
+    return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}:{s} {s}", .{
+        key_color,
+        key,
+        display.Reset,
+        shell[0..(shell.len - 1)],
+    }) };
 }
 
-pub fn getDefaultFormattedCpuInfo(allocator: std.mem.Allocator) !Result {
+pub fn getDefaultFormattedCpuInfo(fmt_ctx: FormatterContext) !Result {
-    return try getFormattedCpuInfo(allocator, "Cpu", ascii.Yellow);
+    return try getFormattedCpuInfo(fmt_ctx, "Cpu", display.Yellow);
 }
 
-pub fn getFormattedCpuInfo(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) !Result {
+pub fn getFormattedCpuInfo(fmt_ctx: FormatterContext, key: []const u8, key_color: []const u8) !Result {
-    const cpu_info = try detection.hardware.getCpuInfo(allocator);
+    const allocator = fmt_ctx.gpa;
+    const io = fmt_ctx.io;
+
+    const cpu_info = if (builtin.os.tag == .macos) try detection.hardware.getCpuInfo(allocator) else if (builtin.os.tag == .linux) try detection.hardware.getCpuInfo(allocator, io);
     defer allocator.free(cpu_info.cpu_name);
-    return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}:{s} {s} ({}) @ {d:.2} GHz", .{ key_color, key, ascii.Reset, cpu_info.cpu_name, cpu_info.cpu_cores, cpu_info.cpu_max_freq }) };
+    return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}:{s} {s} ({}) @ {d:.2} GHz", .{
+        key_color,
+        key,
+        display.Reset,
+        cpu_info.cpu_name,
+        cpu_info.cpu_cores,
+        cpu_info.cpu_max_freq,
+    }) };
 }
 
-pub fn getDefaultFormattedGpuInfo(allocator: std.mem.Allocator) !Result {
+pub fn getDefaultFormattedGpuInfo(fmt_ctx: FormatterContext) !Result {
-    if (builtin.os.tag == .macos) {
+    return try getFormattedGpuInfo(fmt_ctx, "Gpu", display.Yellow);
-        return try getFormattedGpuInfo(allocator, "Gpu", ascii.Yellow);
-    } else if (builtin.os.tag == .linux) {
-        return try getFormattedGpuInfo(allocator, "Gpu", ascii.Yellow);
-    }
 }
 
-pub fn getFormattedGpuInfo(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) !Result {
+pub fn getFormattedGpuInfo(fmt_ctx: FormatterContext, key: []const u8, key_color: []const u8) !Result {
+    const allocator = fmt_ctx.gpa;
+
     if (builtin.os.tag == .macos) {
         const gpu_info = try detection.hardware.getGpuInfo(allocator);
         defer allocator.free(gpu_info.gpu_name);
-        return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}:{s} {s} ({}) @ {d:.2} GHz", .{ key_color, key, ascii.Reset, gpu_info.gpu_name, gpu_info.gpu_cores, gpu_info.gpu_freq }) };
+        return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}:{s} {s} ({}) @ {d:.2} GHz", .{
+            key_color,
+            key,
+            display.Reset,
+            gpu_info.gpu_name,
+            gpu_info.gpu_cores,
+            gpu_info.gpu_freq,
+        }) };
     } else if (builtin.os.tag == .linux) {
         var formatted_gpu_info_list = std.array_list.Managed([]u8).init(allocator);
 
@@ -150,9 +219,21 @@ pub fn getFormattedGpuInfo(allocator: std.mem.Allocator, key: []const u8, key_co
         for (gpu_info_list.items) |g| {
             var formatted_gpu_info: []u8 = undefined;
             if ((g.gpu_cores == 0) or (g.gpu_freq == 0.0)) {
-                formatted_gpu_info = try std.fmt.allocPrint(allocator, "{s}{s}:{s} {s}", .{ key_color, key, ascii.Reset, g.gpu_name });
+                formatted_gpu_info = try std.fmt.allocPrint(allocator, "{s}{s}:{s} {s}", .{
+                    key_color,
+                    key,
+                    display.Reset,
+                    g.gpu_name,
+                });
             } else {
-                formatted_gpu_info = try std.fmt.allocPrint(allocator, "{s}{s}:{s} {s} ({}) @ {d:.2} GHz", .{ key_color, key, ascii.Reset, g.gpu_name, g.gpu_cores, g.gpu_freq });
+                formatted_gpu_info = try std.fmt.allocPrint(allocator, "{s}{s}:{s} {s} ({}) @ {d:.2} GHz", .{
+                    key_color,
+                    key,
+                    display.Reset,
+                    g.gpu_name,
+                    g.gpu_cores,
+                    g.gpu_freq,
+                });
             }
             try formatted_gpu_info_list.append(formatted_gpu_info);
             allocator.free(g.gpu_name);
@@ -163,67 +244,111 @@ pub fn getFormattedGpuInfo(allocator: std.mem.Allocator, key: []const u8, key_co
     }
 }
 
-pub fn getDefaultFormattedRamInfo(allocator: std.mem.Allocator) !Result {
+pub fn getDefaultFormattedRamInfo(fmt_ctx: FormatterContext) !Result {
-    return try getFormattedRamInfo(allocator, "Ram", ascii.Yellow);
+    return try getFormattedRamInfo(fmt_ctx, "Ram", display.Yellow);
 }
 
-pub fn getFormattedRamInfo(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) !Result {
+pub fn getFormattedRamInfo(fmt_ctx: FormatterContext, key: []const u8, key_color: []const u8) !Result {
-    const ram_info = if (builtin.os.tag == .macos) try detection.hardware.getRamInfo() else if (builtin.os.tag == .linux) try detection.hardware.getRamInfo(allocator);
+    const allocator = fmt_ctx.gpa;
-    return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}:{s} {d:.2} / {d:.2} GiB ({}%)", .{ key_color, key, ascii.Reset, ram_info.ram_usage, ram_info.ram_size, ram_info.ram_usage_percentage }) };
+    const io = fmt_ctx.io;
+
+    const ram_info = if (builtin.os.tag == .macos) try detection.hardware.getRamInfo() else if (builtin.os.tag == .linux) try detection.hardware.getRamInfo(allocator, io);
+    return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}:{s} {d:.2} / {d:.2} GiB ({}%)", .{
+        key_color,
+        key,
+        display.Reset,
+        ram_info.ram_usage,
+        ram_info.ram_size,
+        ram_info.ram_usage_percentage,
+    }) };
 }
 
-pub fn getDefaultFormattedSwapInfo(allocator: std.mem.Allocator) !Result {
+pub fn getDefaultFormattedSwapInfo(fmt_ctx: FormatterContext) !Result {
-    return try getFormattedSwapInfo(allocator, "Swap", ascii.Yellow);
+    return try getFormattedSwapInfo(fmt_ctx, "Swap", display.Yellow);
 }
 
-pub fn getFormattedSwapInfo(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) !Result {
+pub fn getFormattedSwapInfo(fmt_ctx: FormatterContext, key: []const u8, key_color: []const u8) !Result {
-    const swap_info = if (builtin.os.tag == .macos) try detection.hardware.getSwapInfo() else if (builtin.os.tag == .linux) try detection.hardware.getSwapInfo(allocator);
+    const allocator = fmt_ctx.gpa;
+    const io = fmt_ctx.io;
+
+    const swap_info = if (builtin.os.tag == .macos) try detection.hardware.getSwapInfo() else if (builtin.os.tag == .linux) try detection.hardware.getSwapInfo(allocator, io);
     if (swap_info) |s| {
-        return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}:{s} {d:.2} / {d:.2} GiB ({}%)", .{ key_color, key, ascii.Reset, s.swap_usage, s.swap_size, s.swap_usage_percentage }) };
+        return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}:{s} {d:.2} / {d:.2} GiB ({}%)", .{
+            key_color,
+            key,
+            display.Reset,
+            s.swap_usage,
+            s.swap_size,
+            s.swap_usage_percentage,
+        }) };
     } else {
-        return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}:{s} Disabled", .{ key_color, key, ascii.Reset }) };
+        return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}:{s} Disabled", .{ key_color, key, display.Reset }) };
     }
 }
 
-pub fn getDefaultFormattedDiskInfo(allocator: std.mem.Allocator) !Result {
+pub fn getDefaultFormattedDiskInfo(fmt_ctx: FormatterContext) !Result {
-    return try getFormattedDiskInfo(allocator, "Disk", ascii.Yellow);
+    return try getFormattedDiskInfo(fmt_ctx, "Disk", display.Yellow);
 }
 
-pub fn getFormattedDiskInfo(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) !Result {
+pub fn getFormattedDiskInfo(fmt_ctx: FormatterContext, key: []const u8, key_color: []const u8) !Result {
+    const allocator = fmt_ctx.gpa;
+
     const disk_info = try detection.hardware.getDiskSize("/");
-    return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s} ({s}):{s} {d:.2} / {d:.2} GB ({}%)", .{ key_color, key, disk_info.disk_path, ascii.Reset, disk_info.disk_usage, disk_info.disk_size, disk_info.disk_usage_percentage }) };
+    return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s} ({s}):{s} {d:.2} / {d:.2} GB ({}%)", .{
+        key_color,
+        key,
+        disk_info.disk_path,
+        display.Reset,
+        disk_info.disk_usage,
+        disk_info.disk_size,
+        disk_info.disk_usage_percentage,
+    }) };
 }
 
-pub fn getDefaultFormattedWindowManagerInfo(allocator: std.mem.Allocator) !Result {
+pub fn getDefaultFormattedWindowManagerInfo(fmt_ctx: FormatterContext) !Result {
-    return try getFormattedWindowManagerInfo(allocator, "WM", ascii.Yellow);
+    return try getFormattedWindowManagerInfo(fmt_ctx, "WM", display.Yellow);
 }
 
-pub fn getFormattedWindowManagerInfo(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) !Result {
+pub fn getFormattedWindowManagerInfo(fmt_ctx: FormatterContext, key: []const u8, key_color: []const u8) !Result {
-    const wm = try detection.system.getWindowManagerInfo(allocator);
+    const allocator = fmt_ctx.gpa;
+    const io = fmt_ctx.io;
+
+    const wm = if (builtin.os.tag == .macos) try detection.system.getWindowManagerInfo(allocator) else if (builtin.os.tag == .linux) try detection.system.getWindowManagerInfo(allocator, io);
     defer allocator.free(wm);
-    return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}:{s} {s}", .{ key_color, key, ascii.Reset, wm }) };
+    return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}:{s} {s}", .{ key_color, key, display.Reset, wm }) };
 }
 
-pub fn getDefaultFormattedTerminalNameInfo(allocator: std.mem.Allocator) !Result {
+pub fn getDefaultFormattedTerminalNameInfo(fmt_ctx: FormatterContext) !Result {
-    return try getFormattedTerminalNameInfo(allocator, "Terminal", ascii.Yellow);
+    return try getFormattedTerminalNameInfo(fmt_ctx, "Terminal", display.Yellow);
 }
 
-pub fn getFormattedTerminalNameInfo(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) !Result {
+pub fn getFormattedTerminalNameInfo(fmt_ctx: FormatterContext, key: []const u8, key_color: []const u8) !Result {
-    const terminal_name = try detection.user.getTerminalName(allocator);
+    const allocator = fmt_ctx.gpa;
+    const environ = fmt_ctx.environ;
+
+    const terminal_name = try detection.user.getTerminalName(allocator, environ);
     defer allocator.free(terminal_name);
-    return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}:{s} {s}", .{ key_color, key, ascii.Reset, terminal_name }) };
+    return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}:{s} {s}", .{ key_color, key, display.Reset, terminal_name }) };
 }
 
-pub fn getDefaultFormattedNetInfo(allocator: std.mem.Allocator) !Result {
+pub fn getDefaultFormattedNetInfo(fmt_ctx: FormatterContext) !Result {
-    return try getFormattedNetInfo(allocator, "Local IP", ascii.Yellow);
+    return try getFormattedNetInfo(fmt_ctx, "Local IP", display.Yellow);
 }
 
-pub fn getFormattedNetInfo(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) !Result {
+pub fn getFormattedNetInfo(fmt_ctx: FormatterContext, key: []const u8, key_color: []const u8) !Result {
+    const allocator = fmt_ctx.gpa;
+
     var formatted_net_info_list = std.array_list.Managed([]u8).init(allocator);
 
     var net_info_list = try detection.network.getNetInfo(allocator);
     for (net_info_list.items) |n| {
-        try formatted_net_info_list.append(try std.fmt.allocPrint(allocator, "{s}{s} ({s}):{s} {s}", .{ key_color, key, n.interface_name, ascii.Reset, n.ipv4_addr }));
+        try formatted_net_info_list.append(try std.fmt.allocPrint(allocator, "{s}{s} ({s}):{s} {s}", .{
+            key_color,
+            key,
+            n.interface_name,
+            display.Reset,
+            n.ipv4_addr,
+        }));
         allocator.free(n.interface_name);
         allocator.free(n.ipv4_addr);
     }
@@ -232,6 +357,8 @@ pub fn getFormattedNetInfo(allocator: std.mem.Allocator, key: []const u8, key_co
     return Result{ .string_arraylist = formatted_net_info_list };
 }
 
-pub fn getFormattedCustom(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) !Result {
+pub fn getFormattedCustom(fmt_ctx: FormatterContext, key: []const u8, key_color: []const u8) !Result {
-    return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}{s}", .{ key_color, key, ascii.Reset }) };
+    const allocator = fmt_ctx.gpa;
+
+    return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}{s}", .{ key_color, key, display.Reset }) };
 }

src/linux/hardware.zig

@@ -40,13 +40,13 @@ pub const DiskInfo = struct {
     disk_usage_percentage: u8,
 };
 
-pub fn getCpuInfo(allocator: std.mem.Allocator) !CpuInfo {
+pub fn getCpuInfo(gpa: std.mem.Allocator, io: std.Io) !CpuInfo {
     const cpu_cores = c_unistd.sysconf(c_unistd._SC_NPROCESSORS_ONLN);
 
     // Reads /proc/cpuinfo
     const cpuinfo_path = "/proc/cpuinfo";
-    const cpuinfo_file = try std.fs.cwd().openFile(cpuinfo_path, .{ .mode = .read_only });
+    const cpuinfo_file = try std.Io.Dir.cwd().openFile(io, cpuinfo_path, .{ .mode = .read_only });
-    defer cpuinfo_file.close();
+    defer cpuinfo_file.close(io);
 
     // NOTE: procfs is a pseudo-filesystem, so it is not possible to determine the size of a file
     // https://docs.kernel.org/filesystems/proc.html
@@ -54,8 +54,8 @@ pub fn getCpuInfo(allocator: std.mem.Allocator) !CpuInfo {
     //
     // Only the first section (core 0) will be parsed
     // 512 is more than enough
-    const cpuinfo_data = try utils.readFile(allocator, cpuinfo_file, 512);
+    const cpuinfo_data = try utils.readFile(gpa, io, cpuinfo_file, 512);
-    defer allocator.free(cpuinfo_data);
+    defer gpa.free(cpuinfo_data);
 
     // Parsing /proc/cpuinfo
     var model_name: ?[]const u8 = null;
@@ -90,18 +90,18 @@ pub fn getCpuInfo(allocator: std.mem.Allocator) !CpuInfo {
     var cmf_exists: bool = true;
 
     // Checks if /sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq exists
-    _ = std.fs.accessAbsolute(cpuinfo_max_freq_path, .{ .mode = .read_only }) catch |err| {
+    _ = std.Io.Dir.accessAbsolute(io, cpuinfo_max_freq_path, .{ .read = true }) catch |err| {
-        if (err == std.posix.AccessError.FileNotFound) {
+        if (err == std.Io.Dir.AccessError.FileNotFound) {
             cmf_exists = false;
         }
     };
 
     if (cmf_exists) {
         // Reads /sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq
-        const maxfreq_file = try std.fs.cwd().openFile(cpuinfo_max_freq_path, .{ .mode = .read_only });
+        const maxfreq_file = try std.Io.Dir.cwd().openFile(io, cpuinfo_max_freq_path, .{ .mode = .read_only });
-        defer maxfreq_file.close();
+        defer maxfreq_file.close(io);
-        const maxfreq_data = try utils.readFile(allocator, maxfreq_file, 32);
+        const maxfreq_data = try utils.readFile(gpa, io, maxfreq_file, 32);
-        defer allocator.free(maxfreq_data);
+        defer gpa.free(maxfreq_data);
 
         // Parsing /sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq
         const trimmed = std.mem.trim(u8, maxfreq_data, " \n\r");
@@ -115,14 +115,14 @@ pub fn getCpuInfo(allocator: std.mem.Allocator) !CpuInfo {
     }
 
     return CpuInfo{
-        .cpu_name = try allocator.dupe(u8, model_name orelse "Unknown"),
+        .cpu_name = try gpa.dupe(u8, model_name orelse "Unknown"),
         .cpu_cores = @as(i32, @intCast(cpu_cores)),
         .cpu_max_freq = cpu_max_freq,
     };
 }
 
-pub fn getGpuInfo(allocator: std.mem.Allocator) !std.array_list.Managed(GpuInfo) {
+pub fn getGpuInfo(gpa: std.mem.Allocator) !std.array_list.Managed(GpuInfo) {
-    var gpu_info_list = std.array_list.Managed(GpuInfo).init(allocator);
+    var gpu_info_list = std.array_list.Managed(GpuInfo).init(gpa);
 
     const display_controller = 0x03;
 
@@ -151,13 +151,13 @@ pub fn getGpuInfo(allocator: std.mem.Allocator) !std.array_list.Managed(GpuInfo)
                 devices.*.device_id,
             );
 
-            const gpu_name = try allocator.dupe(u8, std.mem.span(name));
+            const gpu_name = try gpa.dupe(u8, std.mem.span(name));
 
-            const maybe_parsed_gpu_name = try parseGpuName(allocator, gpu_name);
+            const maybe_parsed_gpu_name = try parseGpuName(gpa, gpu_name);
             var parsed_gpu_name: []u8 = undefined;
 
             if (maybe_parsed_gpu_name != null) {
-                allocator.free(gpu_name);
+                gpa.free(gpu_name);
                 parsed_gpu_name = maybe_parsed_gpu_name.?;
             } else {
                 parsed_gpu_name = gpu_name;
@@ -173,7 +173,7 @@ pub fn getGpuInfo(allocator: std.mem.Allocator) !std.array_list.Managed(GpuInfo)
 
     if (gpu_info_list.items.len == 0) {
         try gpu_info_list.append(GpuInfo{
-            .gpu_name = try allocator.dupe(u8, "Unknown"),
+            .gpu_name = try gpa.dupe(u8, "Unknown"),
             .gpu_cores = 0,
             .gpu_freq = 0.0,
         });
@@ -182,24 +182,24 @@ pub fn getGpuInfo(allocator: std.mem.Allocator) !std.array_list.Managed(GpuInfo)
     return gpu_info_list;
 }
 
-fn parseGpuName(allocator: std.mem.Allocator, name: []u8) !?[]u8 {
+fn parseGpuName(gpa: std.mem.Allocator, name: []u8) !?[]u8 {
     // NOTE: for references: https://github.com/pciutils/pciutils/blob/master/pci.ids
 
     if (std.mem.startsWith(u8, name, "Advanced Micro Devices, Inc. [AMD/ATI]")) {
         const size = std.mem.replacementSize(u8, name, "Advanced Micro Devices, Inc. [AMD/ATI]", "AMD");
-        const parsed_gpu_name = try allocator.alloc(u8, size);
+        const parsed_gpu_name = try gpa.alloc(u8, size);
         _ = std.mem.replace(u8, name, "Advanced Micro Devices, Inc. [AMD/ATI]", "AMD", parsed_gpu_name);
 
         return parsed_gpu_name;
     } else if (std.mem.startsWith(u8, name, "Intel Corporation")) {
         const size = std.mem.replacementSize(u8, name, "Intel Corporation", "Intel");
-        const parsed_gpu_name = try allocator.alloc(u8, size);
+        const parsed_gpu_name = try gpa.alloc(u8, size);
         _ = std.mem.replace(u8, name, "Intel Corporation", "Intel", parsed_gpu_name);
 
         return parsed_gpu_name;
     } else if (std.mem.startsWith(u8, name, "NVIDIA Corporation")) {
         const size = std.mem.replacementSize(u8, name, "NVIDIA Corporation", "NVIDIA");
-        const parsed_gpu_name = try allocator.alloc(u8, size);
+        const parsed_gpu_name = try gpa.alloc(u8, size);
         _ = std.mem.replace(u8, name, "NVIDIA Corporation", "NVIDIA", parsed_gpu_name);
 
         return parsed_gpu_name;
@@ -208,11 +208,11 @@ fn parseGpuName(allocator: std.mem.Allocator, name: []u8) !?[]u8 {
     return null;
 }
 
-pub fn getRamInfo(allocator: std.mem.Allocator) !RamInfo {
+pub fn getRamInfo(gpa: std.mem.Allocator, io: std.Io) !RamInfo {
     // Reads /proc/meminfo
     const meminfo_path = "/proc/meminfo";
-    const meminfo_file = try std.fs.cwd().openFile(meminfo_path, .{ .mode = .read_only });
+    const meminfo_file = try std.Io.Dir.cwd().openFile(io, meminfo_path, .{ .mode = .read_only });
-    defer meminfo_file.close();
+    defer meminfo_file.close(io);
 
     // NOTE: procfs is a pseudo-filesystem, so it is not possible to determine the size of a file
     // https://docs.kernel.org/filesystems/proc.html
@@ -220,8 +220,8 @@ pub fn getRamInfo(allocator: std.mem.Allocator) !RamInfo {
     //
     // We only need to read the first few lines
     // 512 is more than enough
-    const meminfo_data = try utils.readFile(allocator, meminfo_file, 512);
+    const meminfo_data = try utils.readFile(gpa, io, meminfo_file, 512);
-    defer allocator.free(meminfo_data);
+    defer gpa.free(meminfo_data);
 
     // Parsing /proc/meminfo
     var total_mem: f64 = 0.0;
@@ -277,11 +277,11 @@ pub fn getRamInfo(allocator: std.mem.Allocator) !RamInfo {
     };
 }
 
-pub fn getSwapInfo(allocator: std.mem.Allocator) !?SwapInfo {
+pub fn getSwapInfo(gpa: std.mem.Allocator, io: std.Io) !?SwapInfo {
     // Reads /proc/meminfo
     const meminfo_path = "/proc/meminfo";
-    const meminfo_file = try std.fs.cwd().openFile(meminfo_path, .{ .mode = .read_only });
+    const meminfo_file = try std.Io.Dir.cwd().openFile(io, meminfo_path, .{ .mode = .read_only });
-    defer meminfo_file.close();
+    defer meminfo_file.close(io);
 
     // NOTE: procfs is a pseudo-filesystem, so it is not possible to determine the size of a file
     // https://docs.kernel.org/filesystems/proc.html
@@ -289,8 +289,8 @@ pub fn getSwapInfo(allocator: std.mem.Allocator) !?SwapInfo {
     //
     // We only need to read the first few lines
     // 512 is ok
-    const meminfo_data = try utils.readFile(allocator, meminfo_file, 512);
+    const meminfo_data = try utils.readFile(gpa, io, meminfo_file, 512);
-    defer allocator.free(meminfo_data);
+    defer gpa.free(meminfo_data);
 
     // Parsing /proc/meminfo
     var total_swap: f64 = 0.0;

src/linux/linux.zig

@@ -2,3 +2,4 @@ pub const hardware = @import("./hardware.zig");
 pub const network = @import("./network.zig");
 pub const system = @import("./system.zig");
 pub const user = @import("./user.zig");
+pub const packages = @import("./packages.zig");

src/linux/network.zig

@@ -11,8 +11,8 @@ pub const NetInfo = struct {
     ipv4_addr: []u8,
 };
 
-pub fn getNetInfo(allocator: std.mem.Allocator) !std.array_list.Managed(NetInfo) {
+pub fn getNetInfo(gpa: std.mem.Allocator) !std.array_list.Managed(NetInfo) {
-    var net_info_list = std.array_list.Managed(NetInfo).init(allocator);
+    var net_info_list = std.array_list.Managed(NetInfo).init(gpa);
 
     var ifap: ?*c_ifaddrs.ifaddrs = null;
     if (c_ifaddrs.getifaddrs(&ifap) != 0) {
@@ -35,8 +35,8 @@ pub fn getNetInfo(allocator: std.mem.Allocator) !std.array_list.Managed(NetInfo)
             const ip_str = c_inet.inet_ntop(c_inet.AF_INET, &addr_in.sin_addr, &ip_buf, c_inet.INET_ADDRSTRLEN);
             if (ip_str) |ip| {
                 try net_info_list.append(NetInfo{
-                    .interface_name = try allocator.dupe(u8, std.mem.span(ifa.ifa_name)),
+                    .interface_name = try gpa.dupe(u8, std.mem.span(ifa.ifa_name)),
-                    .ipv4_addr = try allocator.dupe(u8, std.mem.span(ip)),
+                    .ipv4_addr = try gpa.dupe(u8, std.mem.span(ip)),
                 });
             }
         }

src/linux/packages.zig

@@ -0,0 +1,254 @@
+const std = @import("std");
+const utils = @import("../utils.zig");
+
+pub fn getPackagesInfo(gpa: std.mem.Allocator, io: std.Io, environ: std.process.Environ) ![]const u8 {
+    var packages_info = std.array_list.Managed(u8).init(gpa);
+    defer packages_info.deinit();
+
+    const flatpak_packages = countFlatpakPackages(io) catch |err| if (err == error.FileNotFound) 0 else return err;
+    const nix_packages = countNixPackages(gpa, io, environ) catch 0;
+    const dpkg_packages = countDpkgPackages(gpa, io) catch |err| if (err == error.FileNotFound) 0 else return err;
+    const pacman_packages = countPacmanPackages(io) catch |err| if (err == error.FileNotFound) 0 else return err;
+    const xbps_packages = countXbpsPackages(gpa, io) catch |err| if (err == error.FileNotFound) 0 else return err;
+
+    var buffer: [32]u8 = undefined;
+
+    if (nix_packages > 0) {
+        try packages_info.appendSlice(try std.fmt.bufPrint(&buffer, " Nix: {d}", .{nix_packages}));
+    }
+
+    if (flatpak_packages > 0) {
+        try packages_info.appendSlice(try std.fmt.bufPrint(&buffer, " Flatpak: {d}", .{flatpak_packages}));
+    }
+
+    if (dpkg_packages > 0) {
+        try packages_info.appendSlice(try std.fmt.bufPrint(&buffer, " Dpkg: {d}", .{dpkg_packages}));
+    }
+
+    if (pacman_packages > 0) {
+        try packages_info.appendSlice(try std.fmt.bufPrint(&buffer, " Pacman: {d}", .{pacman_packages}));
+    }
+
+    if (xbps_packages > 0) {
+        try packages_info.appendSlice(try std.fmt.bufPrint(&buffer, " Xbps: {d}", .{xbps_packages}));
+    }
+
+    return try gpa.dupe(u8, packages_info.items);
+}
+
+fn countFlatpakPackages(io: std.Io) !usize {
+    const flatpak_apps = try countFlatpakApps(io);
+    const flatpak_runtimes = try countFlatpakRuntimes(io);
+
+    return flatpak_apps + flatpak_runtimes;
+}
+
+fn countFlatpakApps(io: std.Io) !usize {
+    var dir = try std.Io.Dir.openDirAbsolute(io, "/var/lib/flatpak/app/", .{ .iterate = true });
+    defer dir.close(io);
+
+    var iter = dir.iterate();
+
+    var count: usize = 0;
+
+    while (try iter.next(io)) |e| {
+        if (e.kind != .directory) continue;
+
+        var sub_dir = try dir.openDir(io, e.name, .{});
+        defer sub_dir.close(io);
+
+        var current = sub_dir.openDir(io, "current", .{}) catch continue;
+        defer current.close(io);
+
+        // If `current` was opened successfully, increment the count
+        count += 1;
+    }
+
+    return count;
+}
+
+fn countFlatpakRuntimes(io: std.Io) !usize {
+    var dir = try std.Io.Dir.openDirAbsolute(io, "/var/lib/flatpak/runtime/", .{ .iterate = true });
+    defer dir.close(io);
+
+    var iter = dir.iterate();
+
+    var counter: usize = 0;
+
+    while (try iter.next(io)) |e| {
+        if (std.mem.endsWith(u8, e.name, ".Locale") or std.mem.endsWith(u8, e.name, ".Debug")) continue;
+
+        var arch_dir = try dir.openDir(io, e.name, .{ .iterate = true });
+        defer arch_dir.close(io);
+        var arch_iter = arch_dir.iterate();
+        while (try arch_iter.next(io)) |arch_e| {
+            if (arch_e.kind != .directory) continue;
+
+            var sub_dir = try arch_dir.openDir(io, arch_e.name, .{ .iterate = true });
+            defer sub_dir.close(io);
+            var sub_iter = sub_dir.iterate();
+            while (try sub_iter.next(io)) |_| {
+                counter += 1;
+            }
+        }
+    }
+
+    return counter;
+}
+
+fn countNixPackages(gpa: std.mem.Allocator, io: std.Io, environ: std.process.Environ) !usize {
+    // `/run/current-system` is a sym-link, so we need to obtein the real path
+    const real_path = try std.Io.Dir.realPathFileAbsoluteAlloc(io, "/run/current-system", gpa);
+    defer gpa.free(real_path);
+
+    var hash: [32]u8 = undefined;
+    std.crypto.hash.Blake3.hash(real_path, &hash, .{});
+    const hash_hex = try std.fmt.allocPrint(gpa, "{x}", .{hash});
+    defer gpa.free(hash_hex);
+
+    var count: usize = 0;
+
+    // Inspired by https://github.com/fastfetch-cli/fastfetch/blob/608382109cda6623e53f318e8aced54cf8e5a042/src/detection/packages/packages_nix.c#L81
+    count = checkNixCache(gpa, io, environ, hash_hex) catch |err| switch (err) {
+        error.FileNotFound, error.InvalidCache => {
+            // nix-store --query --requisites /run/current-system | wc -l
+            const result = try std.process.run(gpa, io, .{ .argv = &[_][]const u8{
+                "sh",
+                "-c",
+                "nix-store --query --requisites /run/current-system | wc -l",
+            } });
+
+            const result_trimmed = std.mem.trim(u8, result.stdout, "\n");
+            defer gpa.free(result.stdout);
+            defer gpa.free(result.stderr);
+
+            count = try std.fmt.parseInt(usize, result_trimmed, 10);
+
+            try writeNixCache(gpa, io, environ, hash_hex, count);
+
+            return count;
+        },
+        else => return err,
+    };
+
+    return count;
+}
+
+fn getNixCachePath(gpa: std.mem.Allocator, environ: std.process.Environ) ![]const u8 {
+    const cache_dir_path = try getUnixCachePath(gpa, environ);
+    defer gpa.free(cache_dir_path);
+    return try std.fs.path.join(gpa, &.{ cache_dir_path, "zigfetch", "nix" });
+}
+
+fn getUnixCachePath(gpa: std.mem.Allocator, environ: std.process.Environ) ![]const u8 {
+    var cache_dir_path = std.process.Environ.getAlloc(environ, gpa, "XDG_CACHE_HOME") catch try gpa.dupe(u8, "");
+    if (cache_dir_path.len == 0) {
+        gpa.free(cache_dir_path);
+        const home = try std.process.Environ.getAlloc(environ, gpa, "HOME");
+        defer gpa.free(home);
+        cache_dir_path = try std.fs.path.join(gpa, &.{ home, ".cache" });
+    }
+
+    return cache_dir_path;
+}
+
+fn writeNixCache(gpa: std.mem.Allocator, io: std.Io, environ: std.process.Environ, hash: []const u8, count: usize) !void {
+    const nix_cache_dir_path = try getNixCachePath(gpa, environ);
+    defer gpa.free(nix_cache_dir_path);
+
+    std.Io.Dir.accessAbsolute(io, nix_cache_dir_path, .{ .read = true }) catch {
+        const cache_dir_path = try getUnixCachePath(gpa, environ);
+        defer gpa.free(cache_dir_path);
+
+        const cache_dir = try std.Io.Dir.openDirAbsolute(io, cache_dir_path, .{});
+        try cache_dir.createDirPath(io, "zigfetch/nix");
+    };
+
+    var nix_cache_dir = try std.Io.Dir.openDirAbsolute(io, nix_cache_dir_path, .{});
+    defer nix_cache_dir.close(io);
+    var cache_file = try nix_cache_dir.createFile(io, "nix_cache", .{ .truncate = true });
+    defer cache_file.close(io);
+
+    const cache_content = try std.fmt.allocPrint(gpa, "{s}\n{d}\n", .{ hash, count });
+    defer gpa.free(cache_content);
+    try cache_file.writePositionalAll(io, cache_content, 0);
+}
+
+fn checkNixCache(gpa: std.mem.Allocator, io: std.Io, environ: std.process.Environ, hash: []const u8) !usize {
+    const cache_dir_path = try getNixCachePath(gpa, environ);
+    defer gpa.free(cache_dir_path);
+    var cache_dir = try std.Io.Dir.openDirAbsolute(io, cache_dir_path, .{});
+    defer cache_dir.close(io);
+
+    var cache_file = try cache_dir.openFile(io, "nix_cache", .{ .mode = .read_only });
+    defer cache_file.close(io);
+    const cache_size = (try cache_file.stat(io)).size;
+    const cache_content = try utils.readFile(gpa, io, cache_file, cache_size);
+    defer gpa.free(cache_content);
+
+    var cache_iter = std.mem.splitScalar(u8, cache_content, '\n');
+
+    const hash_needle = cache_iter.next().?;
+    if (!std.mem.eql(u8, hash, hash_needle)) {
+        return error.InvalidCache;
+    }
+
+    // The next element in the split is the package count
+    return std.fmt.parseInt(usize, cache_iter.next().?, 10);
+}
+
+fn countDpkgPackages(gpa: std.mem.Allocator, io: std.Io) !usize {
+    const dpkg_status_path = "/var/lib/dpkg/status";
+    const dpkg_file = try std.Io.Dir.openFileAbsolute(io, dpkg_status_path, .{ .mode = .read_only });
+    defer dpkg_file.close(io);
+    const file_size = (try dpkg_file.stat(io)).size;
+
+    const content = try utils.readFile(gpa, io, dpkg_file, file_size);
+    defer gpa.free(content);
+
+    var count: usize = 0;
+    var iter = std.mem.splitSequence(u8, content, "\n\n");
+    // TODO: find a way to avoid this loop
+    while (iter.next()) |_| {
+        count += 1;
+    }
+
+    // Subtruct 1 to remove an useless line
+    return count - 1;
+}
+
+fn countPacmanPackages(io: std.Io) !usize {
+    // Subtruct 1 to remove `ALPM_DB_VERSION` from the count
+    return try utils.countEntries(io, "/var/lib/pacman/local") - 1;
+}
+
+fn countXbpsPackages(gpa: std.mem.Allocator, io: std.Io) !usize {
+    var dir = try std.Io.Dir.openDirAbsolute(io, "/var/db/xbps/", .{ .iterate = true });
+    defer dir.close(io);
+
+    var count: usize = 0;
+
+    var dir_iter = dir.iterate();
+
+    while (try dir_iter.next(io)) |e| {
+        if ((e.kind == .file) and std.mem.startsWith(u8, e.name, "pkgdb-")) {
+            const pkgdb_file = try dir.openFile(io, e.name, .{ .mode = .read_only });
+            defer pkgdb_file.close(io);
+            const file_size = (try pkgdb_file.stat(io)).size;
+
+            const content = try utils.readFile(gpa, io, pkgdb_file, file_size);
+            defer gpa.free(content);
+
+            var file_iter = std.mem.splitSequence(u8, content, "<string>installed</string>");
+            // TODO: find a way to avoid this loop
+            while (file_iter.next()) |_| {
+                count += 1;
+            }
+
+            break;
+        }
+    }
+
+    // Subtruct 1 to remove an useless line
+    return count - 1;
+}

src/linux/system.zig

@@ -16,18 +16,18 @@ pub const KernelInfo = struct {
     kernel_release: []u8,
 };
 
-pub fn getHostname(allocator: std.mem.Allocator) ![]u8 {
+pub fn getHostname(gpa: std.mem.Allocator) ![]u8 {
     var buf: [std.posix.HOST_NAME_MAX]u8 = undefined;
     const hostnameEnv = try std.posix.gethostname(&buf);
 
-    const hostname = try allocator.dupe(u8, hostnameEnv);
+    const hostname = try gpa.dupe(u8, hostnameEnv);
 
     return hostname;
 }
 
-pub fn getLocale(allocator: std.mem.Allocator) ![]u8 {
+pub fn getLocale(gpa: std.mem.Allocator, environ: std.process.Environ) ![]u8 {
-    const locale = std.process.getEnvVarOwned(allocator, "LANG") catch |err| if (err == error.EnvironmentVariableNotFound) {
+    const locale = std.process.Environ.getAlloc(environ, gpa, "LANG") catch |err| if (err == error.EnvironmentVariableNotFound) {
-        return allocator.dupe(u8, "Unknown");
+        return gpa.dupe(u8, "Unknown");
     } else return err;
     return locale;
 }
@@ -64,25 +64,25 @@ pub fn getSystemUptime() !SystemUptime {
     };
 }
 
-pub fn getKernelInfo(allocator: std.mem.Allocator) !KernelInfo {
+pub fn getKernelInfo(gpa: std.mem.Allocator) !KernelInfo {
     var uts: c_utsname.struct_utsname = undefined;
     if (c_utsname.uname(&uts) != 0) {
         return error.UnameFailed;
     }
 
     return KernelInfo{
-        .kernel_name = try allocator.dupe(u8, std.mem.sliceTo(&uts.sysname, 0)),
+        .kernel_name = try gpa.dupe(u8, std.mem.sliceTo(&uts.sysname, 0)),
-        .kernel_release = try allocator.dupe(u8, std.mem.sliceTo(&uts.release, 0)),
+        .kernel_release = try gpa.dupe(u8, std.mem.sliceTo(&uts.release, 0)),
     };
 }
 
-pub fn getOsInfo(allocator: std.mem.Allocator) ![]u8 {
+pub fn getOsInfo(gpa: std.mem.Allocator, io: std.Io) ![]u8 {
     const os_release_path = "/etc/os-release";
-    const os_release_file = try std.fs.cwd().openFile(os_release_path, .{ .mode = .read_only });
+    const os_release_file = try std.Io.Dir.cwd().openFile(io, os_release_path, .{ .mode = .read_only });
-    defer os_release_file.close();
+    defer os_release_file.close(io);
-    const size = (try os_release_file.stat()).size;
+    const size = (try os_release_file.stat(io)).size;
-    const os_release_data = try utils.readFile(allocator, os_release_file, size);
+    const os_release_data = try utils.readFile(gpa, io, os_release_file, size);
-    defer allocator.free(os_release_data);
+    defer gpa.free(os_release_data);
 
     var pretty_name: ?[]const u8 = null;
 
@@ -98,18 +98,18 @@ pub fn getOsInfo(allocator: std.mem.Allocator) ![]u8 {
         }
     }
 
-    return try allocator.dupe(u8, pretty_name orelse "Unknown");
+    return try gpa.dupe(u8, pretty_name orelse "Unknown");
 }
 
-pub fn getWindowManagerInfo(allocator: std.mem.Allocator) ![]const u8 {
+pub fn getWindowManagerInfo(gpa: std.mem.Allocator, io: std.Io) ![]const u8 {
-    var dir = try std.fs.cwd().openDir("/proc/", .{ .iterate = true });
+    var dir = try std.Io.Dir.cwd().openDir(io, "/proc/", .{ .iterate = true });
-    defer dir.close();
+    defer dir.close(io);
 
     var wm_name: ?[]const u8 = null;
 
     var iter = dir.iterate();
     wm_name = outer: {
-        while (try iter.next()) |entry| {
+        while (try iter.next(io)) |entry| {
             if (entry.kind != .directory) continue;
 
             // Check if the entry name is numeric
@@ -117,12 +117,12 @@ pub fn getWindowManagerInfo(allocator: std.mem.Allocator) ![]const u8 {
 
             var buf: [1024]u8 = undefined;
             const file_name = try std.fmt.bufPrint(&buf, "/proc/{s}/comm", .{entry.name});
-            const file = try std.fs.cwd().openFile(file_name, .{ .mode = .read_only });
+            const file = try std.Io.Dir.cwd().openFile(io, file_name, .{ .mode = .read_only });
-            defer file.close();
+            defer file.close(io);
 
             // NOTE: https://stackoverflow.com/questions/23534263/what-is-the-maximum-allowed-limit-on-the-length-of-a-process-name
-            const proc_name = try utils.readFile(allocator, file, 16);
+            const proc_name = try utils.readFile(gpa, io, file, 16);
-            defer allocator.free(proc_name);
+            defer gpa.free(proc_name);
 
             const proc_name_trimmed = std.mem.trim(u8, proc_name, "\n");
 
@@ -143,7 +143,7 @@ pub fn getWindowManagerInfo(allocator: std.mem.Allocator) ![]const u8 {
 
             inline for (supported_wms) |wm| {
                 if (std.ascii.eqlIgnoreCase(wm, proc_name_trimmed)) {
-                    break :outer try allocator.dupe(u8, proc_name_trimmed);
+                    break :outer try gpa.dupe(u8, proc_name_trimmed);
                 }
             }
         }
@@ -151,5 +151,5 @@ pub fn getWindowManagerInfo(allocator: std.mem.Allocator) ![]const u8 {
         break :outer null;
     };
 
-    return wm_name orelse allocator.dupe(u8, "Unknown");
+    return wm_name orelse gpa.dupe(u8, "Unknown");
 }

src/linux/user.zig

@@ -1,24 +1,23 @@
 const std = @import("std");
 
-pub fn getUsername(allocator: std.mem.Allocator) ![]u8 {
+pub fn getUsername(gpa: std.mem.Allocator, environ: std.process.Environ) ![]u8 {
-    const username = try std.process.getEnvVarOwned(allocator, "USER");
+    return try std.process.Environ.getAlloc(environ, gpa, "USER");
-    return username;
 }
 
-pub fn getShell(allocator: std.mem.Allocator) ![]u8 {
+pub fn getShell(gpa: std.mem.Allocator, io: std.Io, environ: std.process.Environ) ![]u8 {
-    const shell = std.process.getEnvVarOwned(allocator, "SHELL") catch |err| if (err == error.EnvironmentVariableNotFound) {
+    const shell = std.process.Environ.getAlloc(environ, gpa, "SHELL") catch |err| if (err == error.EnvironmentVariableNotFound) {
-        return allocator.dupe(u8, "Unknown");
+        return gpa.dupe(u8, "Unknown");
     } else return err;
 
-    defer allocator.free(shell);
+    defer gpa.free(shell);
 
-    const result = try std.process.Child.run(.{ .allocator = allocator, .argv = &[_][]const u8{ shell, "--version" } });
+    const result = try std.process.run(gpa, io, .{ .argv = &[_][]const u8{ shell, "--version" } });
     const result_stdout = result.stdout;
 
     if (std.mem.indexOf(u8, shell, "bash") != null) {
         const bash_version = parseBashVersion(result_stdout);
-        defer allocator.free(result_stdout);
+        defer gpa.free(result_stdout);
-        return try std.fmt.allocPrint(allocator, "{s} {s}", .{ "bash", bash_version.? });
+        return try std.fmt.allocPrint(gpa, "{s} {s}", .{ "bash", bash_version.? });
     }
 
     return result_stdout;
@@ -32,12 +31,12 @@ fn parseBashVersion(shell_version_output: []u8) ?[]u8 {
     const version_keyword_index = std.mem.indexOf(u8, shell_version_output[0..end_index.?], version_keyword);
     if (version_keyword_index == null) return null;
 
-    return shell_version_output[version_keyword_index.? + version_keyword.len .. end_index.?];
+    return shell_version_output[version_keyword_index.? + version_keyword.len .. end_index.? + 1];
 }
 
-pub fn getTerminalName(allocator: std.mem.Allocator) ![]u8 {
+pub fn getTerminalName(gpa: std.mem.Allocator, environ: std.process.Environ) ![]u8 {
-    const term_program = std.process.getEnvVarOwned(allocator, "TERM_PROGRAM") catch |err| if (err == error.EnvironmentVariableNotFound) {
+    const term_program = std.process.Environ.getAlloc(environ, gpa, "TERM_PROGRAM") catch |err| if (err == error.EnvironmentVariableNotFound) {
-        return allocator.dupe(u8, "Unknown");
+        return gpa.dupe(u8, "Unknown");
     } else return err;
     return term_program;
 }

src/macos/hardware.zig

@@ -42,7 +42,7 @@ pub const DiskInfo = struct {
     disk_usage_percentage: u8,
 };
 
-pub fn getCpuInfo(allocator: std.mem.Allocator) !CpuInfo {
+pub fn getCpuInfo(gpa: std.mem.Allocator) !CpuInfo {
     var size: usize = 0;
 
     // First call to sysctlbyname to get the size of the string
@@ -50,8 +50,8 @@ pub fn getCpuInfo(allocator: std.mem.Allocator) !CpuInfo {
         return error.FailedToGetCpuNameSize;
     }
 
-    const cpu_name: []u8 = try allocator.alloc(u8, size - 1);
+    const cpu_name: []u8 = try gpa.alloc(u8, size - 1);
-    errdefer allocator.free(cpu_name);
+    errdefer gpa.free(cpu_name);
 
     // Second call to sysctlbyname to get the CPU name
     if (c_sysctl.sysctlbyname("machdep.cpu.brand_string", cpu_name.ptr, &size, null, 0) != 0) {
@@ -66,8 +66,8 @@ pub fn getCpuInfo(allocator: std.mem.Allocator) !CpuInfo {
     }
 
     // Get cpu architecture
-    const arch: []u8 = try getCpuArch(allocator);
+    const arch: []u8 = try getCpuArch(gpa);
-    defer allocator.free(arch);
+    defer gpa.free(arch);
 
     var cpu_freq_mhz: f64 = 0.0;
 
@@ -82,22 +82,22 @@ pub fn getCpuInfo(allocator: std.mem.Allocator) !CpuInfo {
     return CpuInfo{ .cpu_name = cpu_name, .cpu_cores = n_cpu, .cpu_max_freq = cpu_freq_ghz };
 }
 
-fn getCpuArch(allocator: std.mem.Allocator) ![]u8 {
+fn getCpuArch(gpa: std.mem.Allocator) ![]u8 {
     var size: usize = 0;
 
     if (c_sysctl.sysctlbyname("hw.machine", null, &size, null, 0) != 0) {
         return error.SysctlbynameFailed;
     }
 
-    const machine: []u8 = try allocator.alloc(u8, size);
+    const machine: []u8 = try gpa.alloc(u8, size);
 
     if (c_sysctl.sysctlbyname("hw.machine", machine.ptr, &size, null, 0) != 0) {
         return error.SysctlbynameFailed;
     }
 
-    defer allocator.free(machine);
+    defer gpa.free(machine);
 
-    return allocator.dupe(u8, std.mem.sliceTo(machine, 0));
+    return gpa.dupe(u8, std.mem.sliceTo(machine, 0));
 }
 
 fn getCpuFreqAppleSilicon() !f64 {
@@ -184,11 +184,11 @@ pub fn getCpuFreqIntel() f64 {
     return freq / 1_000_000.0;
 }
 
-pub fn getGpuInfo(allocator: std.mem.Allocator) !GpuInfo {
+pub fn getGpuInfo(gpa: std.mem.Allocator) !GpuInfo {
     // TODO: add support for non-Apple Silicon Macs
 
     var gpu_info = GpuInfo{
-        .gpu_name = try allocator.dupe(u8, "Unknown"),
+        .gpu_name = try gpa.dupe(u8, "Unknown"),
         .gpu_cores = 0,
         .gpu_freq = 0.0,
     };
@@ -236,11 +236,11 @@ pub fn getGpuInfo(allocator: std.mem.Allocator) !GpuInfo {
 
         if (c_iokit.CFDictionaryGetValueIfPresent(@as(c_iokit.CFDictionaryRef, @ptrCast(properties_ptr)), model_key, &name_ref) == c_iokit.TRUE) {
             if (c_iokit.CFGetTypeID(name_ref) == c_iokit.CFStringGetTypeID()) {
-                const accel_name = utils.cfTypeRefToZigString(allocator, name_ref) catch {
+                const accel_name = utils.cfTypeRefToZigString(gpa, name_ref) catch {
                     return gpu_info;
                 };
 
-                allocator.free(gpu_info.gpu_name);
+                gpa.free(gpu_info.gpu_name);
                 gpu_info.gpu_name = accel_name;
             }
         }
@@ -262,8 +262,8 @@ pub fn getGpuInfo(allocator: std.mem.Allocator) !GpuInfo {
     }
 
     // Get cpu architecture
-    const arch: []u8 = try getCpuArch(allocator);
+    const arch: []u8 = try getCpuArch(gpa);
-    defer allocator.free(arch);
+    defer gpa.free(arch);
 
     var gpu_freq_mhz: f64 = 0.0;
 

src/macos/network.zig

@@ -11,8 +11,8 @@ pub const NetInfo = struct {
     ipv4_addr: []u8,
 };
 
-pub fn getNetInfo(allocator: std.mem.Allocator) !std.array_list.Managed(NetInfo) {
+pub fn getNetInfo(gpa: std.mem.Allocator) !std.array_list.Managed(NetInfo) {
-    var net_info_list = std.array_list.Managed(NetInfo).init(allocator);
+    var net_info_list = std.array_list.Managed(NetInfo).init(gpa);
 
     var ifap: ?*c_ifaddrs.ifaddrs = null;
     if (c_ifaddrs.getifaddrs(&ifap) != 0) {
@@ -35,8 +35,8 @@ pub fn getNetInfo(allocator: std.mem.Allocator) !std.array_list.Managed(NetInfo)
             const ip_str = c_inet.inet_ntop(c_inet.AF_INET, &addr_in.sin_addr, &ip_buf, c_inet.INET_ADDRSTRLEN);
             if (ip_str) |ip| {
                 try net_info_list.append(NetInfo{
-                    .interface_name = try allocator.dupe(u8, std.mem.span(ifa.ifa_name)),
+                    .interface_name = try gpa.dupe(u8, std.mem.span(ifa.ifa_name)),
-                    .ipv4_addr = try allocator.dupe(u8, std.mem.span(ip)),
+                    .ipv4_addr = try gpa.dupe(u8, std.mem.span(ip)),
                 });
             }
         }

src/macos/packages.zig

@@ -1,13 +1,13 @@
 const std = @import("std");
-const utils = @import("utils.zig");
+const utils = @import("../utils.zig");
 
-pub fn getPackagesInfo(allocator: std.mem.Allocator) ![]const u8 {
+pub fn getPackagesInfo(gpa: std.mem.Allocator, io: std.Io) ![]const u8 {
-    var packages_info = std.array_list.Managed(u8).init(allocator);
+    var packages_info = std.array_list.Managed(u8).init(gpa);
     defer packages_info.deinit();
 
-    const homebrew_packages = countHomebrewPackages() catch |err| if (err == error.FileNotFound) 0 else return err;
+    const homebrew_packages = countHomebrewPackages(io) catch |err| if (err == error.FileNotFound) 0 else return err;
-    const homebrew_casks = countHomebrewCasks() catch |err| if (err == error.FileNotFound) 0 else return err;
+    const homebrew_casks = countHomebrewCasks(io) catch |err| if (err == error.FileNotFound) 0 else return err;
-    const macports_packages = countMacportPackages() catch |err| if (err == error.FileNotFound) 0 else return err;
+    const macports_packages = countMacportPackages(io) catch |err| if (err == error.FileNotFound) 0 else return err;
 
     var buffer: [32]u8 = undefined;
 
@@ -23,17 +23,17 @@ pub fn getPackagesInfo(allocator: std.mem.Allocator) ![]const u8 {
         try packages_info.appendSlice(try std.fmt.bufPrint(&buffer, " macports: {d}", .{macports_packages}));
     }
 
-    return try allocator.dupe(u8, packages_info.items);
+    return try gpa.dupe(u8, packages_info.items);
 }
 
-fn countHomebrewPackages() !usize {
+fn countHomebrewPackages(io: std.Io) !usize {
-    return try utils.countEntries("/opt/homebrew/Cellar");
+    return try utils.countEntries(io, "/opt/homebrew/Cellar");
 }
 
-fn countHomebrewCasks() !usize {
+fn countHomebrewCasks(io: std.Io) !usize {
-    return try utils.countEntries("/opt/homebrew/Caskroom");
+    return try utils.countEntries(io, "/opt/homebrew/Caskroom");
 }
 
-fn countMacportPackages() !usize {
+fn countMacportPackages(io: std.Io) !usize {
-    return try utils.countEntries("/opt/local/bin");
+    return try utils.countEntries(io, "/opt/local/bin");
 }

src/macos/system.zig

@@ -16,18 +16,18 @@ pub const KernelInfo = struct {
 };
 
 /// Returns the hostname.
-pub fn getHostname(allocator: std.mem.Allocator) ![]u8 {
+pub fn getHostname(gpa: std.mem.Allocator) ![]u8 {
     var buf: [std.posix.HOST_NAME_MAX]u8 = undefined;
     const hostnameEnv = try std.posix.gethostname(&buf);
 
-    const hostname = try allocator.dupe(u8, hostnameEnv);
+    const hostname = try gpa.dupe(u8, hostnameEnv);
 
     return hostname;
 }
 
-pub fn getLocale(allocator: std.mem.Allocator) ![]u8 {
+pub fn getLocale(gpa: std.mem.Allocator, environ: std.process.Environ) ![]u8 {
-    const locale = std.process.getEnvVarOwned(allocator, "LANG") catch |err| if (err == error.EnvironmentVariableNotFound) {
+    const locale = std.process.Environ.getAlloc(environ, gpa, "LANG") catch |err| if (err == error.EnvironmentVariableNotFound) {
-        return allocator.dupe(u8, "Unknown");
+        return gpa.dupe(u8, "Unknown");
     } else return err;
     return locale;
 }
@@ -35,7 +35,7 @@ pub fn getLocale(allocator: std.mem.Allocator) ![]u8 {
 /// Returns the system uptime.
 ///
 /// Uses `sysctl` to fetch the system boot time and calculates the elapsed time.
-pub fn getSystemUptime() !SystemUptime {
+pub fn getSystemUptime(io: std.Io) !SystemUptime {
     const seconds_per_day: f64 = 86400.0;
     const hours_per_day: f64 = 24.0;
     const seconds_per_hour: f64 = 3600.0;
@@ -49,7 +49,7 @@ pub fn getSystemUptime() !SystemUptime {
     var name = [_]c_int{ c_sysctl.CTL_KERN, c_sysctl.KERN_BOOTTIME };
     if (c_sysctl.sysctl(&name, name.len, &boot_time, &size, null, 0) == 0) {
         const boot_seconds = @as(f64, @floatFromInt(boot_time.tv_sec));
-        const now_seconds = @as(f64, @floatFromInt(std.time.timestamp()));
+        const now_seconds = @as(f64, @floatFromInt(std.Io.Timestamp.now(io, .real).toSeconds()));
         uptime_seconds = now_seconds - boot_seconds;
     } else {
         return error.UnableToGetSystemUptime;
@@ -71,7 +71,7 @@ pub fn getSystemUptime() !SystemUptime {
     };
 }
 
-pub fn getKernelInfo(allocator: std.mem.Allocator) !KernelInfo {
+pub fn getKernelInfo(gpa: std.mem.Allocator) !KernelInfo {
     var size: usize = 0;
 
     // --- KERNEL NAME ---
@@ -80,8 +80,8 @@ pub fn getKernelInfo(allocator: std.mem.Allocator) !KernelInfo {
         return error.FailedToGetKernelNameSize;
     }
 
-    const kernel_type: []u8 = try allocator.alloc(u8, size - 1);
+    const kernel_type: []u8 = try gpa.alloc(u8, size - 1);
-    errdefer allocator.free(kernel_type);
+    errdefer gpa.free(kernel_type);
 
     // Second call to sysctlbyname to get the kernel name
     if (c_sysctl.sysctlbyname("kern.ostype", kernel_type.ptr, &size, null, 0) != 0) {
@@ -94,8 +94,8 @@ pub fn getKernelInfo(allocator: std.mem.Allocator) !KernelInfo {
         return error.FailedToGetKernelReleaseSize;
     }
 
-    const os_release: []u8 = try allocator.alloc(u8, size - 1);
+    const os_release: []u8 = try gpa.alloc(u8, size - 1);
-    errdefer allocator.free(os_release);
+    errdefer gpa.free(os_release);
 
     // Second call to sysctlbyname to get the kernel release
     if (c_sysctl.sysctlbyname("kern.osrelease", os_release.ptr, &size, null, 0) != 0) {
@@ -108,7 +108,7 @@ pub fn getKernelInfo(allocator: std.mem.Allocator) !KernelInfo {
     };
 }
 
-pub fn getOsInfo(allocator: std.mem.Allocator) ![]u8 {
+pub fn getOsInfo(gpa: std.mem.Allocator) ![]u8 {
     var size: usize = 0;
 
     // First call to sysctlbyname to get the size of the string
@@ -116,20 +116,20 @@ pub fn getOsInfo(allocator: std.mem.Allocator) ![]u8 {
         return error.FailedToGetCpuNameSize;
     }
 
-    const os_version: []u8 = try allocator.alloc(u8, size - 1);
+    const os_version: []u8 = try gpa.alloc(u8, size - 1);
-    defer allocator.free(os_version);
+    defer gpa.free(os_version);
 
     // Second call to sysctlbyname to get the os version
     if (c_sysctl.sysctlbyname("kern.osproductversion", os_version.ptr, &size, null, 0) != 0) {
         return error.FailedToGetOsVersion;
     }
 
-    const os_info = try std.fmt.allocPrint(allocator, "macOS {s}", .{os_version});
+    const os_info = try std.fmt.allocPrint(gpa, "macOS {s}", .{os_version});
 
     return os_info;
 }
 
-pub fn getWindowManagerInfo(allocator: std.mem.Allocator) ![]const u8 {
+pub fn getWindowManagerInfo(gpa: std.mem.Allocator) ![]const u8 {
     var name = [_]c_int{ c_sysctl.CTL_KERN, c_sysctl.KERN_PROC, c_sysctl.KERN_PROC_ALL };
     var size: usize = 0;
 
@@ -138,8 +138,8 @@ pub fn getWindowManagerInfo(allocator: std.mem.Allocator) ![]const u8 {
         return error.SysctlFailed;
     }
 
-    const buffer: []u8 = try allocator.alloc(u8, size);
+    const buffer: []u8 = try gpa.alloc(u8, size);
-    defer allocator.free(buffer);
+    defer gpa.free(buffer);
 
     // Second call to retrieve process data
     if (c_sysctl.sysctl(&name, name.len, buffer.ptr, &size, null, 0) != 0) {
@@ -173,8 +173,8 @@ pub fn getWindowManagerInfo(allocator: std.mem.Allocator) ![]const u8 {
             var pathbuf: [c_libproc.PROC_PIDPATHINFO_MAXSIZE]u8 = undefined;
             // c_libproc.proc_pidpath saves the process name in `pathbuf` and returns the len
             const path_len = @as(usize, @intCast(c_libproc.proc_pidpath(pid, &pathbuf, pathbuf.len)));
-            const proc_pathname = if (path_len > 0) try allocator.dupe(u8, pathbuf[0..@intCast(path_len)]) else try allocator.dupe(u8, "unknown");
+            const proc_pathname = if (path_len > 0) try gpa.dupe(u8, pathbuf[0..@intCast(path_len)]) else try gpa.dupe(u8, "unknown");
-            defer allocator.free(proc_pathname);
+            defer gpa.free(proc_pathname);
 
             inline for (supported_wms) |wm| {
                 if (std.ascii.endsWithIgnoreCase(proc_pathname, wm)) {
@@ -183,7 +183,7 @@ pub fn getWindowManagerInfo(allocator: std.mem.Allocator) ![]const u8 {
                     else
                         proc_pathname;
 
-                    break :outer try allocator.dupe(u8, basename);
+                    break :outer try gpa.dupe(u8, basename);
                 }
             }
         }
@@ -191,5 +191,5 @@ pub fn getWindowManagerInfo(allocator: std.mem.Allocator) ![]const u8 {
         break :outer null;
     };
 
-    return wm_name orelse allocator.dupe(u8, "Quartz Compositor");
+    return wm_name orelse gpa.dupe(u8, "Quartz Compositor");
 }

src/macos/user.zig

@@ -3,25 +3,24 @@ const std = @import("std");
 /// Returns the current logged-in user's username.
 /// Uses the environment variable `USER`.
 /// The caller is responsible for freeing the allocated memory.
-pub fn getUsername(allocator: std.mem.Allocator) ![]u8 {
+pub fn getUsername(gpa: std.mem.Allocator, environ: std.process.Environ) ![]u8 {
-    const username = try std.process.getEnvVarOwned(allocator, "USER");
+    return try std.process.Environ.getAlloc(environ, gpa, "USER");
-    return username;
 }
 
-pub fn getShell(allocator: std.mem.Allocator) ![]u8 {
+pub fn getShell(gpa: std.mem.Allocator, io: std.Io, environ: std.process.Environ) ![]u8 {
-    const shell = std.process.getEnvVarOwned(allocator, "SHELL") catch |err| if (err == error.EnvironmentVariableNotFound) {
+    const shell = std.process.Environ.getAlloc(environ, gpa, "SHELL") catch |err| if (err == error.EnvironmentVariableNotFound) {
-        return allocator.dupe(u8, "Unknown");
+        return gpa.dupe(u8, "Unknown");
     } else return err;
 
-    defer allocator.free(shell);
+    defer gpa.free(shell);
 
-    const result = try std.process.Child.run(.{ .allocator = allocator, .argv = &[_][]const u8{ shell, "--version" } });
+    const result = try std.process.run(gpa, io, .{ .argv = &[_][]const u8{ shell, "--version" } });
     const result_stdout = result.stdout;
 
     if (std.mem.indexOf(u8, shell, "bash") != null) {
         const bash_version = parseBashVersion(result_stdout);
-        defer allocator.free(result_stdout);
+        defer gpa.free(result_stdout);
-        return try std.fmt.allocPrint(allocator, "{s} {s}", .{ "bash", bash_version.? });
+        return try std.fmt.allocPrint(gpa, "{s} {s}", .{ "bash", bash_version.? });
     }
 
     return result_stdout;
@@ -38,9 +37,9 @@ fn parseBashVersion(shell_version_output: []u8) ?[]u8 {
     return shell_version_output[version_keyword_index.? + version_keyword.len .. end_index.?];
 }
 
-pub fn getTerminalName(allocator: std.mem.Allocator) ![]u8 {
+pub fn getTerminalName(gpa: std.mem.Allocator, environ: std.process.Environ) ![]u8 {
-    const term_program = std.process.getEnvVarOwned(allocator, "TERM_PROGRAM") catch |err| if (err == error.EnvironmentVariableNotFound) {
+    const term_program = std.process.Environ.getAlloc(environ, gpa, "TERM_PROGRAM") catch |err| if (err == error.EnvironmentVariableNotFound) {
-        return allocator.dupe(u8, "Unknown");
+        return gpa.dupe(u8, "Unknown");
     } else return err;
     return term_program;
 }

src/macos/utils.zig

@@ -2,15 +2,15 @@ const std = @import("std");
 const c_iokit = @cImport(@cInclude("IOKit/IOKitLib.h"));
 
 /// Converts a CFTypeRef casted to CFStringRef to a Zig string.
-pub fn cfTypeRefToZigString(allocator: std.mem.Allocator, cf_type_ref: c_iokit.CFTypeRef) ![]u8 {
+pub fn cfTypeRefToZigString(gpa: std.mem.Allocator, cf_type_ref: c_iokit.CFTypeRef) ![]u8 {
     const cf_string: c_iokit.CFStringRef = @ptrFromInt(@intFromPtr(cf_type_ref));
 
     const length = c_iokit.CFStringGetLength(cf_string);
     const max_size = c_iokit.CFStringGetMaximumSizeForEncoding(length, c_iokit.kCFStringEncodingUTF8) + 1;
     const max_size_usize = @as(usize, @intCast(max_size));
 
-    const buffer = try allocator.alloc(u8, max_size_usize);
+    const buffer = try gpa.alloc(u8, max_size_usize);
-    errdefer allocator.free(buffer);
+    errdefer gpa.free(buffer);
 
     if (c_iokit.CFStringGetCString(cf_string, buffer.ptr, @as(c_iokit.CFIndex, @intCast(buffer.len)), c_iokit.kCFStringEncodingUTF8) == c_iokit.FALSE) {
         return error.StringConversionFailed;
@@ -21,19 +21,5 @@ pub fn cfTypeRefToZigString(allocator: std.mem.Allocator, cf_type_ref: c_iokit.C
         actual_len += 1;
     }
 
-    return allocator.realloc(buffer, actual_len);
+    return gpa.realloc(buffer, actual_len);
-}
-
-pub fn countEntries(dir_path: []const u8) !usize {
-    var dir = try std.fs.openDirAbsolute(dir_path, .{ .iterate = true });
-    defer dir.close();
-
-    var count: usize = 0;
-    var iter = dir.iterate();
-
-    while (try iter.next()) |_| {
-        count += 1;
-    }
-
-    return count;
 }

src/main.zig

@@ -1,11 +1,12 @@
 const std = @import("std");
 const builtin = @import("builtin");
 const detection = @import("detection.zig").os_module;
-const ascii = @import("ascii.zig");
+const display = @import("display.zig");
 const config = @import("config.zig");
 const formatters = @import("formatters.zig");
 
-pub fn main() !void {
+pub fn main(init: std.process.Init) !void {
+    const io = init.io;
     var gpa = std.heap.GeneralPurposeAllocator(.{}){};
     const allocator = gpa.allocator();
     defer _ = gpa.deinit();
@@ -19,21 +20,21 @@ pub fn main() !void {
         }
     }
 
-    const conf = try config.readConfigFile(allocator);
+    const conf = try config.readConfigFile(allocator, io, init.minimal.environ);
     defer if (conf) |c| c.deinit();
 
     const modules_types = try config.getModulesTypes(allocator, conf);
     defer modules_types.deinit();
 
-    const username = try detection.user.getUsername(allocator);
+    const username = try detection.user.getUsername(allocator, init.minimal.environ);
     const hostname = try detection.system.getHostname(allocator);
 
     const username_hostname_color = if (config.getUsernameHostnameColor(conf)) |color| blk: {
         var buf: [32]u8 = undefined;
-        const rgb = try ascii.hexColorToRgb(color);
+        const rgb = try display.hexColorToRgb(color);
         const formatted_color = try std.fmt.bufPrint(&buf, "\x1b[38;2;{d};{d};{d}m", .{ rgb.r, rgb.g, rgb.b });
         break :blk formatted_color;
-    } else ascii.Yellow;
+    } else display.Yellow;
 
     try modules_list.append(try formatters.getFormattedUsernameHostname(allocator, username_hostname_color, username, hostname));
     allocator.free(hostname);
@@ -43,9 +44,15 @@ pub fn main() !void {
     @memset(separtor_buffer, '-');
     try modules_list.append(separtor_buffer);
 
+    const fmt_ctx = formatters.FormatterContext{
+        .gpa = allocator,
+        .environ = init.minimal.environ,
+        .io = init.io,
+    };
+
     if (modules_types.items.len == 0) {
         inline for (0..formatters.default_formatters.len) |i| {
-            const result = try formatters.default_formatters[i](allocator);
+            const result = try formatters.default_formatters[i](fmt_ctx);
             switch (result) {
                 .string => |r| try modules_list.append(r),
                 .string_arraylist => |r| {
@@ -57,10 +64,10 @@ pub fn main() !void {
     } else if (conf) |c| {
         for (modules_types.items, c.value.modules) |module_type, module| {
             var buf: [32]u8 = undefined;
-            const rgb = try ascii.hexColorToRgb(module.key_color);
+            const rgb = try display.hexColorToRgb(module.key_color);
             const key_color = try std.fmt.bufPrint(&buf, "\x1b[38;2;{d};{d};{d}m", .{ rgb.r, rgb.g, rgb.b });
 
-            const result = try formatters.formatters[@intFromEnum(module_type)](allocator, module.key, key_color);
+            const result = try formatters.formatters[@intFromEnum(module_type)](fmt_ctx, module.key, key_color);
             switch (result) {
                 .string => |r| try modules_list.append(r),
                 .string_arraylist => |r| {
@@ -71,5 +78,6 @@ pub fn main() !void {
         }
     }
 
-    try ascii.printAsciiAndModules(allocator, config.getAsciiPath(conf), modules_list);
+    // TODO: return the formatted ascii and modules to print instead of directly print them
+    try display.printAsciiAndModules(allocator, io, config.getAsciiPath(conf), modules_list);
 }

src/utils.zig

@@ -9,7 +9,7 @@ pub const TermSize = struct {
 pub fn getTerminalSize() !TermSize {
     // https://github.com/softprops/zig-termsize (https://github.com/softprops/zig-termsize/blob/main/src/main.zig)
 
-    const stdout = std.fs.File.stdout();
+    const stdout = std.Io.File.stdout();
 
     switch (builtin.os.tag) {
         .windows => {
@@ -115,13 +115,27 @@ test "getLongestAsciiArtRowLen" {
     try std.testing.expectEqual(40, try getLongestAsciiArtRowLen(rows[0..]));
 }
 
-pub fn readFile(allocator: std.mem.Allocator, file: std.fs.File, size: usize) ![]const u8 {
+pub fn readFile(gpa: std.mem.Allocator, io: std.Io, file: std.Io.File, size: usize) ![]const u8 {
-    var file_buf = try allocator.alloc(u8, size);
+    var file_buf = try gpa.alloc(u8, size);
-    defer allocator.free(file_buf);
+    defer gpa.free(file_buf);
 
-    const read = try file.read(file_buf);
+    const read = try file.readPositionalAll(io, file_buf, 0);
 
     const data = file_buf[0..read];
 
-    return allocator.dupe(u8, data);
+    return gpa.dupe(u8, data);
+}
+
+pub fn countEntries(io: std.Io, dir_path: []const u8) !usize {
+    var dir = try std.Io.Dir.openDirAbsolute(io, dir_path, .{ .iterate = true });
+    defer dir.close(io);
+
+    var count: usize = 0;
+    var iter = dir.iterate();
+
+    while (try iter.next(io)) |_| {
+        count += 1;
+    }
+
+    return count;
 }