Merge pull request #2551 from fastfetch-cli/dev

Release: v2.68.0

.clang-format

@@ -0,0 +1,89 @@
+# find . -type f \( -name "*.c" -o -name "*.h" -o -name "*.cpp" -o -name "*.hpp" -o -name "*.m" -o -name "*.mm" \) -print0 | xargs -0 clang-format -i
+
+BasedOnStyle: LLVM
+
+UseTab: Never
+IndentWidth: 4
+TabWidth: 4
+ContinuationIndentWidth: 4
+
+ColumnLimit: 0
+ReflowComments: true
+
+BreakBeforeBraces: Attach
+BreakBeforeCloseBracketBracedList: true
+BraceWrapping:
+  AfterControlStatement: false
+  AfterEnum: false
+  AfterFunction: false
+  AfterStruct: false
+  AfterUnion: false
+  AfterExternBlock: false
+  BeforeElse: false
+  BeforeCatch: false
+  SplitEmptyFunction: false
+  SplitEmptyRecord: false
+  SplitEmptyNamespace: false
+IndentExternBlock: NoIndent
+
+AllowShortIfStatementsOnASingleLine: AllIfsAndElse
+AllowShortLoopsOnASingleLine: true
+AllowShortBlocksOnASingleLine: true
+AllowShortFunctionsOnASingleLine: Empty
+InsertBraces: true
+
+PointerAlignment: Left
+DerivePointerAlignment: false
+SpaceBeforeParens: ControlStatements
+SpacesInParentheses: false
+SpaceAfterCStyleCast: true
+SpacesInLineCommentPrefix:
+  Minimum: 1
+  Maximum: 1
+SpacesInContainerLiterals: true
+
+SortIncludes: Never
+IndentPPDirectives: BeforeHash
+PPIndentWidth: 4
+
+IndentCaseLabels: true
+
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignOperands: DontAlign
+
+BinPackParameters: false
+BinPackArguments: false
+AlignAfterOpenBracket: DontAlign
+BracedInitializerIndentWidth: 4
+Cpp11BracedListStyle: Block
+
+ForEachMacros:
+  - FF_LIST_FOR_EACH
+  - yyjson_obj_foreach
+  - yyjson_arr_foreach
+  - yyjson_mut_obj_foreach
+  - yyjson_mut_arr_foreach
+
+AttributeMacros:
+  - FF_A_FALLTHROUGH
+  - FF_A_DEPRECATED
+  - FF_A_CLEANUP
+  - FF_A_NODISCARD
+  - FF_A_PRINTF
+  - FF_A_SCANF
+  - FF_A_NONNULL
+  - FF_A_RETURNS_NONNULL
+  - FF_A_UNUSED
+  - FF_A_PACKED
+  - FF_A_WEAK_IMPORT
+
+MaxEmptyLinesToKeep: 1
+KeepEmptyLinesAtTheStartOfBlocks: false
+
+---
+Language: ObjC
+ObjCBlockIndentWidth: 4
+ObjCSpaceAfterProperty: true
+ObjCSpaceBeforeProtocolList: true
+ObjCBreakBeforeNestedBlockParam: true

.clang-format-ignore

@@ -0,0 +1,3 @@
+src/3rdparty/**
+build/**
+src/logo/builtin.c

.codespellrc

@@ -1,5 +1,5 @@
 [codespell]
 check-filenames =
 builtin = clear,rare,usage,informal
-skip = */.git,*/cmake-build-*,*/.idea,*/completions,*/presets,*/screenshots,*/tests,*/3rdparty,*/logo/ascii,./src/detection/gpu/asahi_drm.h
-ignore-words-list = iterm,compiletime,unknwn,pengwin,siduction,master,slave,sur,doas,conexant,ags,bu
+skip = */.git,*/cmake-build-*,*/.idea,*/completions,*/presets,*/screenshots,*/tests,*/3rdparty,*/logo/ascii,./src/detection/gpu/asahi_drm.h,./src/detection/cpu/cpu_x86.c,./src/detection/gpu/gpu_bsddrm.c,./src/detection/displayserver/linux/wayland/*-protocol.*,./build,./build-*,./build_*,./src/common/impl/genconfig.c
+ignore-words-list = iterm,compiletime,unknwn,pengwin,siduction,master,slave,sur,doas,conexant,ags,bu,renderD,SME,Carmel,kinda,symbole,connexion,comando,processus,lokale,adres,titel,som,environnement,Sistem,Lokal,Lokal,Sistem,Paket,Hava

.github/ISSUE_TEMPLATE/logo_request.yml

@@ -6,16 +6,31 @@ body:
   - type: markdown
     attributes:
       value: |
-        Tip: You can display a logo in fastfetch without adding it to fastfetch's official repo.
+        > [!WARNING]
+        > **NB:** If your logo request does not meet the basic requirements outlined in this template, the issue may be closed at any time without any further explanation.
+
+        **Tip:** You can display a logo in fastfetch without adding it to fastfetch's official repo.
         For highly customized, personal logos, we recommend keeping them locally.
-        Please refer to https://github.com/fastfetch-cli/fastfetch/wiki/Migrate-Neofetch-Logo-To-Fastfetch
+        You can test your logo locally using:
+        `fastfetch -l /path/to/logo.txt --logo-color-1 white --logo-color-2 red`
+        Please refer to the [Migration Guide](https://github.com/fastfetch-cli/fastfetch/wiki/Migrate-Neofetch-Logo-To-Fastfetch) for details on color placeholders (`$1`, `$2`, etc.).
+
   - type: textarea
     attributes:
       label: OS
-      description: Paste the contents of `/etc/os-release` and `/etc/lsb-release` here. If neither file exists, describe how to identify the distro.
+      description: Paste the contents of `/etc/os-release` (specifically the `ID` and `PRETTY_NAME` fields). If neither file exists, describe how to identify the distro.
       placeholder: cat /etc/os-release
     validations:
       required: true
+
+  - type: input
+    attributes:
+      label: Public repository URL
+      description: A public repository is required to verify the request. Please provide a link to the repository where the distro is developed.
+      placeholder: https://github.com/example/distro
+    validations:
+      required: true
+
   - type: input
     attributes:
       label: Distro Website
@@ -23,25 +38,35 @@ body:
       placeholder: https://example.com
     validations:
       required: true
+
   - type: textarea
     attributes:
       label: ASCII Art
-      description: The ASCII logo should not take up too much space (smaller than 50x20 characters, W x H). Please also include the color codes if they are not available in `os-release`.
-      placeholder: Paste ASCII art here
+      description: |
+        The ASCII logo should not take up too much space (smaller than 50x20 characters, W x H).
+        **Important:** Fastfetch uses `$1`, `$2`, `$3` etc. for color placeholders. Do NOT use hardcoded ANSI escape codes (like `\033[38;2...m`) or Neofetch's `${c1}` syntax.
+        Take <https://github.com/fastfetch-cli/fastfetch/tree/dev/src/logo/ascii> as examples.
+      placeholder: Paste ASCII art with $1, $2 placeholders here
     validations:
       required: true
+
   - type: input
     attributes:
       label: Original Image URL
       description: If the ASCII art is based on an image, please provide a link to the original image file.
       placeholder: Image URL from the distro website mentioned above
+
   - type: checkboxes
     attributes:
       label: Checklist
       options:
+        - label: My distro has reached a stable state (out of beta, alpha, RC).
+          required: true
         - label: The ASCII art is smaller than 50x20 characters (W x H).
           required: true
-        - label: The ASCII art includes color codes, or the color codes are available in `os-release`.
+        - label: The ASCII art uses `$N` color placeholders (or colors are natively available in `os-release`).
           required: true
-        - label: The ASCII art has no internal padding (spaces at the start and/or end of lines).
+        - label: The ASCII art has no unnecessary trailing spaces at the end of lines.
+          required: true
+        - label: I promise that I will send a removal request if the distro is discontinued.
           required: true

.github/benchmark-index.html

@@ -0,0 +1,405 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Fastfetch · Benchmark</title>
+  <style>
+    :root {
+      color-scheme: light;
+      --page: #f5f7fb;
+      --card: #fff;
+      --text: #172033;
+      --muted: #64748b;
+      --border: #dbe3ef;
+      --accent: #2563eb;
+      --accent-soft: #dbeafe;
+      --chart-text: #334155;
+      --chart-grid: #cbd5e1;
+    }
+    :root[data-theme="dark"] {
+      color-scheme: dark;
+      --page: #0f172a; --card: #172033; --text: #e5edf8; --muted: #9aabc1; --border: #334155; --accent-soft: #1e3a8a;
+      --chart-text: #f1f5f9;
+      --chart-grid: #475569;
+    }
+    * { box-sizing: border-box; }
+    body { max-width: 1440px; margin: 0 auto; padding: 2.5rem 1.25rem 4rem; background: var(--page); color: var(--text); font: 16px/1.5 system-ui, -apple-system, sans-serif; }
+    header { margin-bottom: 1.75rem; }
+    .header-row { display: flex; align-items: center; justify-content: space-between; gap: 1rem; }
+    h1 { margin: 0; font-size: clamp(2rem, 4vw, 3rem); letter-spacing: -.04em; }
+    h2 { margin: 0; font-size: 1.25rem; }
+    p { color: var(--muted); }
+    .intro { margin: .6rem 0 1rem; }
+    .links a { color: var(--accent); font-weight: 600; text-decoration: none; }
+    .links a:hover { text-decoration: underline; }
+    .theme-toggle, .fullscreen { border: 1px solid var(--border); border-radius: .55rem; padding: .5rem .8rem; background: var(--card); color: var(--text); cursor: pointer; font: inherit; font-weight: 600; }
+    .theme-toggle:hover, .fullscreen:hover { border-color: var(--accent); color: var(--accent); }
+    .tabs { display: flex; flex-wrap: wrap; gap: .6rem; margin: 1.5rem 0; padding: .35rem; border: 1px solid var(--border); border-radius: .8rem; background: var(--card); }
+    .tab { border: 0; border-radius: .55rem; padding: .65rem 1.15rem; background: transparent; color: var(--muted); cursor: pointer; font: inherit; font-weight: 700; }
+    .tab:hover, .tab[aria-selected="true"] { background: var(--accent); color: #fff; }
+    .tab-panel[hidden] { display: none; }
+    .platform-title { display: flex; align-items: center; gap: .65rem; margin: 1.5rem 0 1rem; }
+    .platform-title::before { content: ''; width: .35rem; height: 1.4rem; border-radius: 1rem; background: var(--accent); }
+    .charts { display: flex; flex-direction: column; gap: 1.25rem; }
+    .chart { min-width: 0; padding: 1.25rem; border: 1px solid var(--border); border-radius: 1rem; background: var(--card); box-shadow: 0 8px 28px #0f172a0c; }
+    .chart:fullscreen { overflow: auto; padding: 2rem; background: var(--page); }
+    .chart:fullscreen .canvas-wrap { height: calc(100vh - 13rem); }
+    .chart-header { display: flex; align-items: baseline; justify-content: space-between; gap: 1rem; margin-bottom: .75rem; }
+    .chart-header span { color: var(--muted); font-size: .85rem; }
+    .canvas-wrap { position: relative; height: 360px; }
+    .chart-actions { display: flex; align-items: center; gap: .75rem; }
+    .legend-actions { display: flex; flex-wrap: wrap; gap: .45rem; margin-top: 1rem; }
+    .legend-action { border: 1px solid var(--border); border-radius: .45rem; padding: .35rem .6rem; background: var(--card); color: var(--muted); cursor: pointer; font: inherit; font-size: .8rem; }
+    .legend-action:hover { border-color: var(--accent); color: var(--accent); }
+    .legend { display: flex; flex-wrap: wrap; gap: .35rem .9rem; margin-top: 1rem; }
+    .legend-item { display: inline-flex; align-items: center; gap: .4rem; border: 0; padding: .15rem 0; background: transparent; color: var(--text); cursor: pointer; font: inherit; font-size: .85rem; }
+    .legend-item.is-hidden { color: var(--muted); }
+    .legend-swatch { width: .75rem; height: .75rem; border-radius: 50%; }
+    .legend-item.is-hidden .legend-swatch { opacity: .35; }
+    .chart-tooltip { position: fixed; z-index: 1000; pointer-events: none; width: min(90vw, 900px); max-height: calc(100vh - 24px); overflow: hidden; padding: .7rem .85rem; border: 1px solid var(--border); border-radius: .6rem; background: var(--card); color: var(--text); box-shadow: 0 10px 30px #0f172a33; font-size: .8rem; opacity: 0; transition: opacity .1s ease; }
+    .chart-tooltip-title { margin-bottom: .35rem; font-weight: 700; white-space: normal; overflow-wrap: anywhere; }
+    .chart-tooltip-body { max-height: calc(100vh - 76px); overflow: auto; columns: 220px auto; column-gap: 1.5rem; }
+    .chart-tooltip-row { display: flex; align-items: center; gap: .45rem; break-inside: avoid; white-space: nowrap; }
+    .chart-tooltip-swatch { width: .55rem; height: .55rem; border-radius: 50%; flex: 0 0 auto; }
+    .empty { padding: 2rem 0; color: var(--muted); }
+  </style>
+  <script src="https://cdn.jsdelivr.net/npm/chart.js/dist/chart.umd.min.js"></script>
+  <script src="data.js"></script>
+</head>
+<body>
+  <header>
+    <div class="header-row">
+      <h1>Fastfetch Benchmark</h1>
+      <button id="theme-toggle" class="theme-toggle" type="button"></button>
+    </div>
+    <p class="intro">Performance history grouped by CPU family. Each chart contains all modules and total process time for one operating system and architecture. Module curves are available from the legend and hidden by default.</p>
+    <p class="links"><a href="data.js">Download raw benchmark data</a></p>
+  </header>
+  <nav id="tabs" class="tabs" aria-label="CPU architecture"></nav>
+  <main id="panels"></main>
+  <script>
+    (() => {
+      const benchmarkData = window.BENCHMARK_DATA || {};
+      const entries = Object.values(benchmarkData.entries || {}).flat();
+      const groups = new Map();
+
+      function architectureFamily(arch) {
+        const normalized = arch.toLowerCase();
+        if (/^(amd64|x86_64|x86|i[3-6]86)$/.test(normalized)) return 'Intel';
+        if (/^(aarch64|arm64|armv[5-8].*|arm)$/.test(normalized)) return 'ARM';
+        return 'Other';
+      }
+
+      function parseName(name) {
+        let match = name.match(/^fastfetch (linux|macos|windows) ([^ ]+) (module .+|total process time)$/i);
+        if (match) {
+          return { platform: match[1].toLowerCase(), arch: match[2], metric: match[3] };
+        }
+
+        // Keep older macOS records visible while new records use the platform field.
+        match = name.match(/^fastfetch ([^ ]+) (module .+|total process time)$/i);
+        return match ? { platform: 'macos', arch: match[1], metric: match[2] } : null;
+      }
+
+      function entryMetadata(entry) {
+        const raw = entry.commit && entry.commit.timestamp || entry.date;
+        const date = new Date(raw);
+        return {
+          date: Number.isNaN(date.valueOf()) ? String(entry.date || '') : date.toISOString(),
+          sha: entry.commit && entry.commit.id ? entry.commit.id : 'unknown'
+        };
+      }
+
+      for (const entry of entries) {
+        const metricsByGroup = new Map();
+        for (const bench of entry.benches || []) {
+          const parsed = parseName(bench.name);
+          if (!parsed) continue;
+          const key = `${parsed.platform} ${parsed.arch}`;
+          if (!metricsByGroup.has(key)) metricsByGroup.set(key, new Map());
+          metricsByGroup.get(key).set(parsed.metric, bench.value);
+        }
+
+        for (const [key, metrics] of metricsByGroup) {
+          if (!groups.has(key)) groups.set(key, []);
+          groups.get(key).push({ ...entryMetadata(entry), metrics });
+        }
+      }
+
+      const colors = [
+        '#2563eb', '#dc2626', '#16a34a', '#9333ea', '#ea580c', '#0891b2',
+        '#db2777', '#65a30d', '#4f46e5', '#ca8a04', '#0f766e', '#be123c'
+      ];
+      const tabs = document.getElementById('tabs');
+      const panels = document.getElementById('panels');
+      const root = document.documentElement;
+      const themeToggle = document.getElementById('theme-toggle');
+      const savedTheme = localStorage.getItem('fastfetch-benchmark-theme');
+      let theme = savedTheme || (matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light');
+      const chartsByInstance = [];
+
+      function chartColors() {
+        const styles = getComputedStyle(root);
+        return {
+          text: styles.getPropertyValue('--chart-text').trim(),
+          grid: styles.getPropertyValue('--chart-grid').trim()
+        };
+      }
+
+      function externalTooltipHandler(context) {
+        const { chart, tooltip } = context;
+        let tooltipElement = chart.canvas.parentNode.querySelector('.chart-tooltip');
+        if (!tooltipElement) {
+          tooltipElement = document.createElement('div');
+          tooltipElement.className = 'chart-tooltip';
+          chart.canvas.parentNode.appendChild(tooltipElement);
+        }
+
+        if (tooltip.opacity === 0) {
+          tooltipElement.style.opacity = '0';
+          return;
+        }
+
+        tooltipElement.replaceChildren();
+        const title = document.createElement('div');
+        title.className = 'chart-tooltip-title';
+        const row = chart._benchmarkRows[tooltip.dataPoints[0].dataIndex];
+        title.textContent = `${new Date(row.date).toLocaleString()} · ${row.sha}`;
+        tooltipElement.appendChild(title);
+        const bodyElement = document.createElement('div');
+        bodyElement.className = 'chart-tooltip-body';
+        for (const body of [...tooltip.dataPoints].sort((a, b) => b.parsed.y - a.parsed.y)) {
+          const item = document.createElement('div');
+          item.className = 'chart-tooltip-row';
+          const swatch = document.createElement('span');
+          swatch.className = 'chart-tooltip-swatch';
+          swatch.style.background = body.dataset.borderColor;
+          const value = document.createElement('span');
+          value.textContent = `${body.dataset.label}: ${body.formattedValue} ms`;
+          item.append(swatch, value);
+          bodyElement.appendChild(item);
+        }
+        tooltipElement.appendChild(bodyElement);
+
+        const canvasRect = chart.canvas.getBoundingClientRect();
+        const margin = 12;
+        let left = canvasRect.left + tooltip.caretX + margin;
+        let top = canvasRect.top + tooltip.caretY + margin;
+        tooltipElement.style.left = `${left}px`;
+        tooltipElement.style.top = `${top}px`;
+        tooltipElement.style.opacity = '0';
+        const tooltipRect = tooltipElement.getBoundingClientRect();
+        if (left + tooltipRect.width > window.innerWidth - margin) left = canvasRect.left + tooltip.caretX - tooltipRect.width - margin;
+        if (top + tooltipRect.height > window.innerHeight - margin) top = canvasRect.top + tooltip.caretY - tooltipRect.height - margin;
+        tooltipElement.style.left = `${Math.max(margin, left)}px`;
+        tooltipElement.style.top = `${Math.max(margin, top)}px`;
+        tooltipElement.style.opacity = '1';
+      }
+
+      function updateTheme() {
+        root.dataset.theme = theme;
+        themeToggle.textContent = theme === 'dark' ? '☀ Light mode' : '☾ Dark mode';
+        themeToggle.setAttribute('aria-label', `Switch to ${theme === 'dark' ? 'light' : 'dark'} mode`);
+        const colors = chartColors();
+        Chart.defaults.color = colors.text;
+        Chart.defaults.borderColor = colors.grid;
+        for (const chart of chartsByInstance) {
+          chart.options.scales.x.title.color = colors.text;
+          chart.options.scales.x.ticks.color = colors.text;
+          chart.options.scales.x.grid.color = colors.grid;
+          chart.options.scales.y.title.color = colors.text;
+          chart.options.scales.y.ticks.color = colors.text;
+          chart.options.scales.y.grid.color = colors.grid;
+          chart.update();
+        }
+      }
+      themeToggle.addEventListener('click', () => {
+        theme = theme === 'dark' ? 'light' : 'dark';
+        localStorage.setItem('fastfetch-benchmark-theme', theme);
+        updateTheme();
+      });
+      updateTheme();
+      const families = new Map();
+
+      for (const [key, rows] of groups) {
+        const arch = key.slice(key.lastIndexOf(' ') + 1);
+        const family = architectureFamily(arch);
+        if (!families.has(family)) families.set(family, []);
+        families.get(family).push({ key, rows });
+      }
+
+      const familyOrder = ['Intel', 'ARM', 'Other'];
+      const availableFamilies = familyOrder.filter(family => families.has(family));
+
+      for (const [index, family] of availableFamilies.entries()) {
+        const tab = document.createElement('button');
+        const panelId = `panel-${family.toLowerCase()}`;
+        tab.className = 'tab';
+        tab.type = 'button';
+        tab.id = `tab-${family.toLowerCase()}`;
+        tab.setAttribute('role', 'tab');
+        tab.textContent = family;
+        tab.setAttribute('aria-controls', panelId);
+        tab.setAttribute('aria-selected', index === 0 ? 'true' : 'false');
+        tabs.appendChild(tab);
+
+        const panel = document.createElement('section');
+        panel.className = 'tab-panel';
+        panel.id = panelId;
+        panel.setAttribute('role', 'tabpanel');
+        panel.hidden = index !== 0;
+        panel.setAttribute('aria-labelledby', tab.id);
+        const title = document.createElement('h2');
+        title.className = 'platform-title';
+        title.textContent = `${family} processors`;
+        panel.appendChild(title);
+        const chartGrid = document.createElement('div');
+        chartGrid.className = 'charts';
+        panel.appendChild(chartGrid);
+        panels.appendChild(panel);
+
+        tab.addEventListener('click', () => {
+          for (const otherTab of tabs.children) otherTab.setAttribute('aria-selected', otherTab === tab ? 'true' : 'false');
+          for (const otherPanel of panels.children) otherPanel.hidden = otherPanel !== panel;
+        });
+
+        for (const { key, rows } of families.get(family).sort((a, b) => a.key.localeCompare(b.key))) {
+          rows.sort((a, b) => a.date.localeCompare(b.date));
+          const metrics = [...new Set(rows.flatMap(row => [...row.metrics.keys()]))].sort((a, b) => {
+            if (a === 'total process time') return -1;
+            if (b === 'total process time') return 1;
+            return a.localeCompare(b);
+          });
+          const section = document.createElement('article');
+          section.className = 'chart';
+          const chartHeader = document.createElement('div');
+          chartHeader.className = 'chart-header';
+          const chartTitle = document.createElement('h2');
+          chartTitle.textContent = key;
+          const chartActions = document.createElement('div');
+          chartActions.className = 'chart-actions';
+          const chartHint = document.createElement('span');
+          chartHint.textContent = `${rows.length} run${rows.length === 1 ? '' : 's'}`;
+          const fullscreen = document.createElement('button');
+          fullscreen.className = 'fullscreen';
+          fullscreen.type = 'button';
+          fullscreen.textContent = '⛶ Fullscreen';
+          fullscreen.addEventListener('click', () => {
+            if (document.fullscreenElement) document.exitFullscreen();
+            else section.requestFullscreen();
+          });
+          chartActions.append(chartHint, fullscreen);
+          chartHeader.append(chartTitle, chartActions);
+          const canvasWrap = document.createElement('div');
+          canvasWrap.className = 'canvas-wrap';
+          const canvas = document.createElement('canvas');
+          canvasWrap.appendChild(canvas);
+          section.append(chartHeader, canvasWrap);
+          chartGrid.appendChild(section);
+
+          const colorsForChart = chartColors();
+          const chart = new Chart(canvas, {
+            type: 'line',
+            data: {
+              labels: rows.map(row => row.sha.slice(0, 7)),
+              datasets: metrics.map((metric, index) => ({
+                label: metric,
+                data: rows.map(row => row.metrics.has(metric) ? row.metrics.get(metric) : null),
+                borderColor: colors[index % colors.length],
+                backgroundColor: colors[index % colors.length],
+                pointRadius: 3,
+                tension: 0.2,
+                spanGaps: true,
+                hidden: metric !== 'total process time'
+              }))
+            },
+            options: {
+              responsive: true,
+              maintainAspectRatio: false,
+              interaction: { mode: 'index', intersect: false },
+              plugins: {
+                legend: { display: false },
+                tooltip: {
+                  enabled: false,
+                  external: externalTooltipHandler,
+                  callbacks: {
+                    title: tooltipItems => {
+                      const row = rows[tooltipItems[0].dataIndex];
+                      return `${row.date} · ${row.sha}`;
+                    }
+                  }
+                }
+              },
+              scales: {
+                x: { title: { display: true, text: 'Date', color: colorsForChart.text }, ticks: { color: colorsForChart.text }, grid: { color: colorsForChart.grid } },
+                y: { beginAtZero: true, title: { display: true, text: 'Milliseconds', color: colorsForChart.text }, ticks: { color: colorsForChart.text }, grid: { color: colorsForChart.grid } }
+              }
+            }
+          });
+          chart._benchmarkRows = rows;
+          chartsByInstance.push(chart);
+          const legendActions = document.createElement('div');
+          legendActions.className = 'legend-actions';
+          const legend = document.createElement('div');
+          legend.className = 'legend';
+          const legendItems = [];
+
+          function refreshLegend() {
+            legendItems.forEach((item, metricIndex) => {
+              item.classList.toggle('is-hidden', !chart.isDatasetVisible(metricIndex));
+            });
+          }
+
+          function setAllLegends(visible) {
+            metrics.forEach((metric, metricIndex) => chart.setDatasetVisibility(metricIndex, visible));
+            refreshLegend();
+            chart.update();
+          }
+
+          function addLegendAction(label, action) {
+            const button = document.createElement('button');
+            button.className = 'legend-action';
+            button.type = 'button';
+            button.textContent = label;
+            button.addEventListener('click', action);
+            legendActions.appendChild(button);
+          }
+
+          addLegendAction('Show all', () => setAllLegends(true));
+          addLegendAction('Toggle all', () => {
+            metrics.forEach((metric, metricIndex) => chart.setDatasetVisibility(metricIndex, !chart.isDatasetVisible(metricIndex)));
+            refreshLegend();
+            chart.update();
+          });
+          addLegendAction('Reset', () => {
+            metrics.forEach((metric, metricIndex) => chart.setDatasetVisibility(metricIndex, metric === 'total process time'));
+            refreshLegend();
+            chart.update();
+          });
+
+          metrics.forEach((metric, metricIndex) => {
+            const item = document.createElement('button');
+            item.className = `legend-item${chart.isDatasetVisible(metricIndex) ? '' : ' is-hidden'}`;
+            item.type = 'button';
+            item.innerHTML = `<span class="legend-swatch" style="background:${colors[metricIndex % colors.length]}"></span>${metric}`;
+            item.addEventListener('click', () => {
+              chart.setDatasetVisibility(metricIndex, !chart.isDatasetVisible(metricIndex));
+              item.classList.toggle('is-hidden', !chart.isDatasetVisible(metricIndex));
+              chart.update();
+            });
+            legendItems.push(item);
+            legend.appendChild(item);
+          });
+          section.append(legendActions, legend);
+        }
+      }
+
+      if (!groups.size) {
+        tabs.hidden = true;
+        panels.innerHTML = '<p class="empty">No benchmark data available.</p>';
+      }
+    })();
+  </script>
+</body>
+</html>

.github/dependabot.yml

@@ -0,0 +1,18 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+      day: "sunday"
+    cooldown:
+      default-days: 7
+    open-pull-requests-limit: 10
+    commit-message:
+      prefix: "CI"
+    labels:
+      - "ci"
+    groups:
+      github-actions:
+        patterns:
+          - "*"

.github/pull_request_template.md

@@ -21,6 +21,10 @@ Closes #
 
 - 
 
+## Screenshots
+
+<!-- Required if this PR introduces visual changes. -->
+
 ## Checklist
 
 - [ ] I have tested my changes locally.

.github/workflows/build-benchmark.yml

@@ -0,0 +1,55 @@
+name: Reusable Benchmark
+
+on:
+  workflow_call:
+
+permissions:
+  contents: write
+
+jobs:
+  benchmark:
+    runs-on: ubuntu-latest
+    concurrency:
+      group: benchmark
+      cancel-in-progress: false
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: download benchmark data
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        with:
+          pattern: benchmark-*
+          path: benchmarks
+
+      - name: merge benchmark data
+        run: jq -s 'add' benchmarks/*/benchmark.json > benchmark.json
+
+      - name: save benchmark dashboard
+        run: cp .github/benchmark-index.html "$RUNNER_TEMP/benchmark-index.html"
+
+      - name: store benchmark result
+        uses: benchmark-action/github-action-benchmark@52576c92bccf6ac60c8223ec7eb2565637cae9ba # v1.22.1
+        with:
+          name: Fastfetch
+          tool: customSmallerIsBetter
+          output-file-path: benchmark.json
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          ref: ${{ github.sha }}
+          auto-push: true
+          summary-always: true
+          benchmark-data-dir-path: dev/bench
+
+      - name: publish benchmark dashboard
+        run: |
+          git fetch origin gh-pages
+          git switch --force-create gh-pages FETCH_HEAD
+          mkdir -p dev/bench
+          cp "$RUNNER_TEMP/benchmark-index.html" dev/bench/index.html
+          git config user.name github-action-benchmark
+          git config user.email github@users.noreply.github.com
+          git add dev/bench/index.html
+          if ! git diff --cached --quiet; then
+            git commit -m "Update benchmark dashboard"
+            git push origin gh-pages
+          fi

.github/workflows/build-dragonfly-amd64.yml

@@ -0,0 +1,66 @@
+name: Reusable DragonFly amd64
+
+on:
+  workflow_call:
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        shell: cpa.sh {0}
+
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: Start VM
+        uses: cross-platform-actions/action@faa0c6197e94aacf1c5956460152c8380d3560a5 # v1.5.0
+        with:
+          operating_system: dragonflybsd
+          version: '6.4.2'
+          shell: bash
+          cpu_count: 4
+
+      - name: Show system info
+        run: |
+          uname -a
+          pkg --version
+
+      - name: Update and install dependencies
+        run: |
+          sudo pkg update
+          sudo pkg install -y llvm cmake git pkgconf binutils wayland vulkan-headers vulkan-loader libxcb libXrandr libX11 libdrm glib dconf dbus sqlite3-tcl egl opencl ocl-icd v4l_compat chafa libelf lua54 libva libvdpau
+
+      - name: CMake configuration
+        run: env CC=clang cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DENABLE_EMBEDDED_PCIIDS=On -DENABLE_EMBEDDED_AMDGPUIDS=On -DCMAKE_BUILD_TYPE=${{ vars.CMAKE_BUILD_TYPE || 'RelWithDebInfo' }} .
+
+      - name: CMake build
+        run: cmake --build . --target package --verbose -j4
+
+      - name: List features
+        run: ./fastfetch --list-features
+
+      - name: Run normal
+        run: time ./fastfetch -c presets/ci.jsonc --stat false
+
+      - name: Run json
+        run: time ./fastfetch -c presets/ci.jsonc --format json
+
+      - name: Run flashfetch
+        run: time ./flashfetch
+
+      - name: Run ldd
+        run: ldd fastfetch
+
+      - name: Run tests
+        run: ctest --output-on-failure
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: fastfetch-dragonfly-amd64
+          path: ./fastfetch-*.*

.github/workflows/build-freebsd-amd64.yml

@@ -0,0 +1,67 @@
+name: Reusable FreeBSD amd64
+
+on:
+  workflow_call:
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        shell: cpa.sh {0}
+
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: Start VM
+        uses: cross-platform-actions/action@faa0c6197e94aacf1c5956460152c8380d3560a5 # v1.5.0
+        with:
+          operating_system: freebsd
+          version: '15.1'
+          shell: bash
+          cpu_count: 4
+
+      - name: Show system info
+        run: |
+          uname -a
+          freebsd-version
+          pkg -v
+
+      - name: Update and install dependencies
+        run: |
+          sudo pkg update
+          sudo pkg install -y cmake git pkgconf binutils wayland vulkan-headers vulkan-loader libxcb libXrandr libX11 libdrm glib dconf dbus sqlite3 egl opencl ocl-icd v4l_compat chafa lua54 libva libvdpau
+
+      - name: CMake configuration
+        run: cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DENABLE_EMBEDDED_PCIIDS=On -DENABLE_EMBEDDED_AMDGPUIDS=On -DCMAKE_BUILD_TYPE=${{ vars.CMAKE_BUILD_TYPE || 'RelWithDebInfo' }} .
+
+      - name: CMake build
+        run: cmake --build . --target package --verbose -j4
+
+      - name: List features
+        run: ./fastfetch --list-features
+
+      - name: Run normal
+        run: time ./fastfetch -c presets/ci.jsonc --stat false
+
+      - name: Run json
+        run: time ./fastfetch -c presets/ci.jsonc --format json
+
+      - name: Run flashfetch
+        run: time ./flashfetch
+
+      - name: Run ldd
+        run: ldd fastfetch
+
+      - name: Run tests
+        run: ctest --output-on-failure
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: fastfetch-freebsd-amd64
+          path: ./fastfetch-*.*

.github/workflows/build-haiku-amd64.yml

@@ -0,0 +1,60 @@
+name: Reusable Haiku amd64
+
+on:
+  workflow_call:
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        shell: cpa.sh {0}
+
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: Start VM
+        uses: cross-platform-actions/action@faa0c6197e94aacf1c5956460152c8380d3560a5 # v1.5.0
+        with:
+          operating_system: haiku
+          version: 'r1beta6'
+          shell: bash
+          cpu_count: 4
+
+      - name: Show system info
+        run: uname -a
+
+      - name: Install dependencies
+        shell: cpa.sh {0} --reboot
+        run: pkgman install -y git dbus_devel mesa_devel libelf_devel imagemagick_devel opencl_headers ocl_icd_devel vulkan_devel zlib_devel chafa_devel cmake llvm22_clang ninja pkgconfig python3.10 lua || pkgman install -y git dbus_devel mesa_devel libelf_devel imagemagick_devel opencl_headers ocl_icd_devel vulkan_devel zlib_devel chafa_devel cmake llvm22_clang ninja pkgconfig python3.10 lua
+
+      - name: CMake configuration
+        run: CC=clang CXX=clang++ cmake -GNinja -DSET_TWEAK=Off -DBUILD_TESTS=On -DENABLE_EMBEDDED_PCIIDS=On -DENABLE_EMBEDDED_AMDGPUIDS=On -DCMAKE_BUILD_TYPE=${{ vars.CMAKE_BUILD_TYPE || 'RelWithDebInfo' }} .
+
+      - name: CMake build
+        run: cmake --build . --target package --verbose -j4
+
+      - name: List features
+        run: ./fastfetch --list-features
+
+      - name: Run normal
+        run: time ./fastfetch -c presets/ci.jsonc --stat false
+
+      - name: Run json
+        run: time ./fastfetch -c presets/ci.jsonc --format json
+
+      - name: Run flashfetch
+        run: time ./flashfetch
+
+      - name: Run tests
+        run: ctest --output-on-failure
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: fastfetch-haiku-amd64
+          path: ./fastfetch-*.*

.github/workflows/build-linux-armv7l.yml

@@ -0,0 +1,47 @@
+name: Reusable Linux armv7l
+
+on:
+  workflow_call:
+
+permissions:
+  contents: read
+
+env:
+  CMAKE_BUILD_TYPE: ${{ vars.CMAKE_BUILD_TYPE || 'RelWithDebInfo' }}
+
+jobs:
+  build:
+    runs-on: ubuntu-24.04
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: run VM
+        uses: uraimo/run-on-arch-action@460cb8e6d9f726a588fc9b5e681c8a6cab09ae41 # v3.2.0
+        id: runcmd
+        with:
+          arch: armv7
+          distro: ubuntu22.04
+          githubToken: ${{ github.token }}
+          run: |
+            uname -a
+            apt-get update && apt-get install -y software-properties-common ca-certificates gpg curl
+            add-apt-repository -y ppa:ubuntu-toolchain-r/test
+            curl -L https://apt.kitware.com/keys/kitware-archive-latest.asc | gpg --dearmor - | tee /usr/share/keyrings/kitware-archive-keyring.gpg >/dev/null
+            echo 'deb [signed-by=/usr/share/keyrings/kitware-archive-keyring.gpg] https://apt.kitware.com/ubuntu/ jammy main' | tee /etc/apt/sources.list.d/kitware.list >/dev/null
+            echo -e 'Acquire::https::Verify-Peer "false";\nAcquire::https::Verify-Host "false";' >> /etc/apt/apt.conf.d/99ignore-certificates
+            apt-get update && apt-get install -y cmake make gcc-13 libvulkan-dev libwayland-dev libxrandr-dev libxcb-randr0-dev libdconf-dev libdbus-1-dev libmagickcore-dev libsqlite3-dev librpm-dev libegl-dev libglx-dev ocl-icd-opencl-dev libpulse-dev libdrm-dev libelf-dev libefl-all-dev liblua5.4-dev libvdpau-dev libva-dev rpm
+            CC=gcc-13 cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DCMAKE_INSTALL_PREFIX=/usr .
+            cmake --build . --target package --verbose -j4
+            ./fastfetch --list-features
+            time ./fastfetch -c presets/ci.jsonc --stat false
+            time ./fastfetch -c presets/ci.jsonc --format json
+            time ./flashfetch
+            ldd fastfetch
+            ctest --output-on-failure
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: fastfetch-linux-armv7l
+          path: ./fastfetch-*.*

.github/workflows/build-linux-hosts.yml

@@ -0,0 +1,135 @@
+name: Reusable Linux Hosts
+
+on:
+  workflow_call:
+    inputs:
+      arch:
+        required: true
+        type: string
+      runs-on:
+        required: true
+        type: string
+    outputs:
+      ffversion:
+        description: fastfetch version from linux host build
+        value: ${{ jobs.build.outputs.ffversion }}
+
+permissions:
+  security-events: write
+  contents: read
+
+env:
+  CMAKE_BUILD_TYPE: ${{ vars.CMAKE_BUILD_TYPE || 'RelWithDebInfo' }}
+
+jobs:
+  build:
+    runs-on: ${{ inputs.runs-on }}
+    outputs:
+      ffversion: ${{ steps.ffversion.outputs.ffversion }}
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: uname -a
+        run: uname -a
+
+      - name: cat /etc/os-release
+        run: cat /etc/os-release
+
+      - name: cat /proc/cpuinfo
+        run: cat /proc/cpuinfo
+
+      - name: add gcc-13 repo
+        run: sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
+
+      - name: install required packages
+        run: sudo apt-get update && sudo apt-get install -y gcc-13 jq libvulkan-dev libwayland-dev libxrandr-dev libxcb-randr0-dev libdconf-dev libdbus-1-dev libmagickcore-dev libsqlite3-dev librpm-dev libegl-dev libglx-dev ocl-icd-opencl-dev libpulse-dev libdrm-dev libelf-dev libddcutil-dev libefl-all-dev libunwind-dev liblua5.4-dev libvdpau-dev libva-dev rpm ninja-build
+
+      - name: install linuxbrew packages
+        run: |
+          /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
+          /home/linuxbrew/.linuxbrew/bin/brew install imagemagick chafa quickjs-ng --ignore-dependencies
+
+      - name: Initialize CodeQL
+        if: inputs.arch == 'amd64'
+        uses: github/codeql-action/init@db488ddef3bf6cb639b32c2e9a7c0a7ea8271d28 # v4.37.8
+        with:
+          languages: c
+
+      - name: configure project
+        run: CC=gcc-13 CMAKE_PREFIX_PATH=/home/linuxbrew/.linuxbrew PKG_CONFIG_PATH=/home/linuxbrew/.linuxbrew/lib/pkgconfig:$PKG_CONFIG_PATH cmake -GNinja -DSET_TWEAK=Off -DBUILD_TESTS=On -DENABLE_EMBEDDED_PCIIDS=On -DENABLE_EMBEDDED_AMDGPUIDS=On -DCMAKE_INSTALL_PREFIX=/usr .
+
+      - name: build project
+        run: cmake --build . --target package --verbose -j4
+
+      - name: perform CodeQL analysis
+        if: inputs.arch == 'amd64'
+        uses: github/codeql-action/analyze@db488ddef3bf6cb639b32c2e9a7c0a7ea8271d28 # v4.37.8
+
+      - name: list features
+        run: ./fastfetch --list-features
+
+      - name: run fastfetch
+        run: time ./fastfetch -c presets/ci.jsonc --stat false
+
+      - name: run fastfetch --format json
+        run: |
+          { time -p ./fastfetch -c presets/ci.jsonc --format json > fastfetch.raw.json 2> fastfetch.error; } 2> fastfetch.time
+          sed -n '/^[[:space:]]*\[/,$p' fastfetch.raw.json > fastfetch.json
+          cat fastfetch.json
+          cat fastfetch.error >&2
+          cat fastfetch.time >&2
+
+      - name: prepare benchmark data
+        run: |
+          real_seconds=$(awk '$1 == "real" { print $2 }' fastfetch.time)
+          jq -e 'type == "array"' fastfetch.json > /dev/null
+          jq --arg platform "linux" --arg arch "${{ inputs.arch }}" --argjson real_seconds "$real_seconds" '
+            map(select(.stat | type == "number") | {
+              name: ("fastfetch " + $platform + " " + $arch + " module " + .type),
+              unit: "ms",
+              value: .stat
+            }) + [{
+              name: ("fastfetch " + $platform + " " + $arch + " total process time"),
+              unit: "ms",
+              value: ($real_seconds * 1000)
+            }]
+          ' fastfetch.json > benchmark.json
+          cat benchmark.json
+
+      - name: run flashfetch
+        run: time ./flashfetch
+
+      - name: print dependencies
+        run: ldd fastfetch
+
+      - name: run tests
+        run: ctest --output-on-failure
+
+      - name: get fastfetch version
+        id: ffversion
+        run: echo "ffversion=$(./fastfetch --version-raw)" >> $GITHUB_OUTPUT
+
+      - name: polyfill glibc
+        run: |
+          wget https://github.com/CarterLi/polyfill-glibc/releases/download/v0.0.1/polyfill-glibc-${{ inputs.arch }} -O polyfill-glibc
+          chmod +x polyfill-glibc
+          strip fastfetch && ./polyfill-glibc fastfetch --target-glibc=2.17
+          strip flashfetch && ./polyfill-glibc flashfetch --target-glibc=2.17
+          echo 'set(CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_FILE_NAME}-polyfilled")' >> CPackConfig.cmake
+          echo 'set(CPACK_PACKAGE_RELOCATABLE OFF)' >> CPackConfig.cmake
+          echo 'set(CPACK_DEBIAN_PACKAGE_DEPENDS "libc6 (>= 2.17)")' >> CPackConfig.cmake
+          echo 'set(CPACK_RPM_SPEC_MORE_DEFINE "%global __os_install_post %{nil}")' >> CPackConfig.cmake
+          cpack -V
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: fastfetch-linux-${{ inputs.arch }}
+          path: ./fastfetch-*.*
+
+      - name: upload benchmark data
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: benchmark-linux-${{ inputs.arch }}
+          path: benchmark.json

.github/workflows/build-linux-i686.yml

@@ -0,0 +1,73 @@
+name: Reusable Linux i686
+
+on:
+  workflow_call:
+
+permissions:
+  contents: read
+
+env:
+  CMAKE_BUILD_TYPE: ${{ vars.CMAKE_BUILD_TYPE || 'RelWithDebInfo' }}
+
+jobs:
+  build:
+    runs-on: ubuntu-22.04
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: uname -a
+        run: uname -a
+
+      - name: cat /etc/os-release
+        run: cat /etc/os-release
+
+      - name: cat /proc/cpuinfo
+        run: cat /proc/cpuinfo
+
+      - name: add gcc-13 repo
+        run: sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
+
+      - name: install required packages
+        run: sudo apt-get update && sudo apt-get install -y gcc-13 gcc-13-multilib libvulkan-dev libwayland-dev libxrandr-dev libxcb-randr0-dev libdconf-dev libdbus-1-dev libmagickcore-dev libsqlite3-dev librpm-dev libegl-dev libglx-dev ocl-icd-opencl-dev libpulse-dev libdrm-dev libelf-dev libddcutil-dev libefl-all-dev libunwind-dev liblua5.4-dev libvdpau-dev libva-dev rpm ninja-build
+
+      - name: install linuxbrew packages
+        run: |
+          /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
+          /home/linuxbrew/.linuxbrew/bin/brew install imagemagick chafa quickjs-ng --ignore-dependencies
+
+      - name: cmake version
+        run: cmake --version
+
+      - name: configure project
+        run: CC=gcc-13 CMAKE_PREFIX_PATH=/home/linuxbrew/.linuxbrew PKG_CONFIG_PATH=/home/linuxbrew/.linuxbrew/lib/pkgconfig:$PKG_CONFIG_PATH cmake -DCMAKE_C_FLAGS="-m32 -march=i686 -mtune=i686" -DCMAKE_SYSTEM_PROCESSOR_OVERRIDE=i686 -DCPACK_DEBIAN_PACKAGE_ARCHITECTURE=i386 -GNinja -DSET_TWEAK=Off -DBUILD_TESTS=On -DENABLE_EMBEDDED_PCIIDS=On -DENABLE_EMBEDDED_AMDGPUIDS=On -DCMAKE_INSTALL_PREFIX=/usr .
+
+      - name: build project
+        run: cmake --build . --target package --verbose -j4
+
+      - name: check deb package
+        run: dpkg -I fastfetch-*.deb
+
+      - name: list features
+        run: ./fastfetch --list-features
+
+      - name: run fastfetch
+        run: time ./fastfetch -c presets/ci.jsonc --stat false
+
+      - name: run fastfetch --format json
+        run: time ./fastfetch -c presets/ci.jsonc --format json
+
+      - name: run flashfetch
+        run: time ./flashfetch
+
+      - name: print dependencies
+        run: ldd fastfetch
+
+      - name: run tests
+        run: ctest --output-on-failure
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: fastfetch-linux-i686
+          path: ./fastfetch-*.*

.github/workflows/build-linux-loong64.yml

@@ -0,0 +1,60 @@
+name: Reusable Linux loong64
+
+on:
+  workflow_call:
+
+permissions:
+  contents: read
+
+env:
+  CMAKE_BUILD_TYPE: ${{ vars.CMAKE_BUILD_TYPE || 'RelWithDebInfo' }}
+
+jobs:
+  build:
+    runs-on: ubuntu-24.04
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: set up QEMU for loong64
+        uses: docker/setup-qemu-action@96fe6ef7f33517b61c61be40b68a1882f3264fb8 # v4.2.0
+
+      - name: build in loong64 container
+        run: |
+          docker run --rm --platform linux/loong64 \
+            -v ${{ github.workspace }}:/workspace \
+            -w /workspace \
+            lcr.loongnix.cn/debian:14 \
+            bash -c '
+              set -e
+              uname -a
+              cat /etc/os-release || true
+
+              apt-get update
+              apt-get install -y --no-install-recommends \
+                cmake make gcc g++ \
+                libvulkan-dev libwayland-dev libxrandr-dev libxcb-randr0-dev \
+                libdconf-dev libdbus-1-dev libmagickcore-dev \
+                libsqlite3-dev librpm-dev \
+                libegl-dev libglx-dev ocl-icd-opencl-dev \
+                libpulse-dev libdrm-dev \
+                libelf-dev libefl-all-dev \
+                liblua5.4-dev \
+                libvdpau-dev libva-dev \
+                rpm
+
+              cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DCMAKE_INSTALL_PREFIX=/usr .
+              cmake --build . --target package --verbose -j$(nproc)
+              ./fastfetch --list-features
+              time ./fastfetch -c presets/ci.jsonc --stat false
+              time ./fastfetch -c presets/ci.jsonc --format json
+              time ./flashfetch
+              ldd fastfetch
+              ctest --output-on-failure
+            '
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: fastfetch-linux-loong64
+          path: ./fastfetch-*.*

.github/workflows/build-linux-vms.yml

@@ -0,0 +1,48 @@
+name: Reusable Linux VMs
+
+on:
+  workflow_call:
+    inputs:
+      arch:
+        required: true
+        type: string
+
+permissions:
+  contents: read
+
+env:
+  CMAKE_BUILD_TYPE: ${{ vars.CMAKE_BUILD_TYPE || 'RelWithDebInfo' }}
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: run VM
+        uses: uraimo/run-on-arch-action@460cb8e6d9f726a588fc9b5e681c8a6cab09ae41 # v3.2.0
+        id: runcmd
+        with:
+          arch: ${{ inputs.arch }}
+          distro: ubuntu22.04
+          githubToken: ${{ github.token }}
+          run: |
+            uname -a
+            apt-get update && apt-get install -y software-properties-common
+            add-apt-repository -y ppa:ubuntu-toolchain-r/test
+            apt-get update && apt-get install -y cmake make gcc-13 libvulkan-dev libwayland-dev libxrandr-dev libxcb-randr0-dev libdconf-dev libdbus-1-dev libmagickcore-dev libsqlite3-dev librpm-dev libegl-dev libglx-dev ocl-icd-opencl-dev libpulse-dev libdrm-dev libchafa-dev libelf-dev libefl-all-dev liblua5.4-dev libvdpau-dev libva-dev rpm
+            CC=gcc-13 cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DCMAKE_INSTALL_PREFIX=/usr .
+            cmake --build . --target package --verbose -j4
+            ./fastfetch --list-features
+            time ./fastfetch -c presets/ci.jsonc --stat false
+            time ./fastfetch -c presets/ci.jsonc --format json
+            time ./flashfetch
+            ldd fastfetch
+            ctest --output-on-failure
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: fastfetch-linux-${{ inputs.arch }}
+          path: ./fastfetch-*.*

.github/workflows/build-macos-hosts.yml

@@ -0,0 +1,90 @@
+name: Reusable macOS Hosts
+
+on:
+  workflow_call:
+    inputs:
+      arch:
+        required: true
+        type: string
+      runs-on:
+        required: true
+        type: string
+
+permissions:
+  contents: read
+
+env:
+  CMAKE_BUILD_TYPE: ${{ vars.CMAKE_BUILD_TYPE || 'RelWithDebInfo' }}
+
+jobs:
+  build:
+    runs-on: ${{ inputs.runs-on }}
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: uname -a
+        run: uname -a
+
+      - name: install required packages
+        run: |
+          HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK=1 brew update
+          HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK=1 brew install --overwrite vulkan-loader vulkan-headers molten-vk imagemagick chafa lua quickjs-ng jq
+
+      - name: configure project
+        run: cmake -DSET_TWEAK=Off -DBUILD_TESTS=On .
+
+      - name: build project
+        run: cmake --build . --target package --verbose -j4
+
+      - name: list features
+        run: ./fastfetch --list-features
+
+      - name: run fastfetch
+        run: time ./fastfetch -c presets/ci.jsonc --structure-disabled vulkan:bluetooth:bluetoothradio --stat false
+
+      - name: run fastfetch --format json
+        run: |
+          { time -p ./fastfetch -c presets/ci.jsonc --structure-disabled vulkan:bluetooth:bluetoothradio --format json > fastfetch.raw.json 2> fastfetch.error; } 2> fastfetch.time
+          sed -n '/^[[:space:]]*\[/,$p' fastfetch.raw.json > fastfetch.json
+          cat fastfetch.json
+          cat fastfetch.error >&2
+          cat fastfetch.time >&2
+
+      - name: prepare benchmark data
+        run: |
+          real_seconds=$(awk '$1 == "real" { print $2 }' fastfetch.time)
+          jq -e 'type == "array"' fastfetch.json > /dev/null
+          jq --arg platform "macos" --arg arch "${{ inputs.arch }}" --argjson real_seconds "$real_seconds" '
+            map(select(.stat | type == "number") | {
+              name: ("fastfetch " + $platform + " " + $arch + " module " + .type),
+              unit: "ms",
+              value: .stat
+            }) + [{
+              name: ("fastfetch " + $platform + " " + $arch + " total process time"),
+              unit: "ms",
+              value: ($real_seconds * 1000)
+            }]
+          ' fastfetch.json > benchmark.json
+          cat benchmark.json
+
+      - name: run flashfetch
+        run: time ./flashfetch
+
+      - name: print dependencies
+        run: otool -L fastfetch
+
+      - name: run tests
+        run: ctest --output-on-failure
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: fastfetch-macos-${{ inputs.arch }}
+          path: ./fastfetch-*.*
+
+      - name: upload benchmark data
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: benchmark-macos-${{ inputs.arch }}
+          path: benchmark.json

.github/workflows/build-musl-amd64.yml

@@ -0,0 +1,50 @@
+name: Reusable Musl amd64
+
+on:
+  workflow_call:
+
+permissions:
+  contents: read
+
+env:
+  CMAKE_BUILD_TYPE: ${{ vars.CMAKE_BUILD_TYPE || 'RelWithDebInfo' }}
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: setup alpine linux
+        uses: jirutka/setup-alpine@ae3b3ddba35054804fc4a3507b519fa7e8152050 # v1.4.1
+        with:
+          branch: edge
+
+      - name: install dependencies
+        run: |
+          cat /etc/alpine-release
+          uname -a
+          apk add cmake samurai vulkan-loader-dev libxcb-dev libxrandr-dev rpm-dev wayland-dev libdrm-dev dconf-dev imagemagick-dev chafa-dev zlib-dev dbus-dev mesa-dev opencl-dev sqlite-dev networkmanager-dev pulseaudio-dev ddcutil-dev elfutils-dev lua5.4-dev quickjs-ng-dev libvdpau-dev libva-dev gcc g++
+        shell: alpine.sh --root {0}
+
+      - name: build
+        run: |
+            cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DCMAKE_INSTALL_PREFIX=/usr -DIS_MUSL=ON -DENABLE_EMBEDDED_PCIIDS=On -DENABLE_EMBEDDED_AMDGPUIDS=On -GNinja .
+            cmake --build . --target package --verbose -j4
+        shell: alpine.sh {0}
+
+      - name: run
+        run: |
+            ./fastfetch --list-features
+            time ./fastfetch -c presets/ci.jsonc --stat false
+            time ./fastfetch -c presets/ci.jsonc --format json
+            time ./flashfetch
+            ldd fastfetch
+            ctest --output-on-failure
+        shell: alpine.sh {0}
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: fastfetch-musl-amd64
+          path: ./fastfetch-*.*

.github/workflows/build-netbsd-amd64.yml

@@ -0,0 +1,65 @@
+name: Reusable NetBSD amd64
+
+on:
+  workflow_call:
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        shell: cpa.sh {0}
+
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: Start VM
+        uses: cross-platform-actions/action@faa0c6197e94aacf1c5956460152c8380d3560a5 # v1.5.0
+        with:
+          operating_system: netbsd
+          version: '10.1'
+          shell: bash
+          cpu_count: 4
+
+      - name: Show system info
+        run: |
+          uname -a
+          pkgin -v
+
+      - name: Update and install dependencies
+        run: |
+          sudo pkgin -y install clang cmake git pkgconf wayland vulkan-headers dconf dbus sqlite3 ImageMagick libva libvdpau
+
+      - name: CMake configuration
+        run: CC=clang cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DENABLE_EMBEDDED_PCIIDS=On -DENABLE_EMBEDDED_AMDGPUIDS=On -DCMAKE_BUILD_TYPE=${{ vars.CMAKE_BUILD_TYPE || 'RelWithDebInfo' }} .
+
+      - name: CMake build
+        run: cmake --build . --target package --verbose -j4
+
+      - name: List features
+        run: ./fastfetch --list-features
+
+      - name: Run normal
+        run: time ./fastfetch -c presets/ci.jsonc --stat false
+
+      - name: Run json
+        run: time ./fastfetch -c presets/ci.jsonc --format json
+
+      - name: Run flashfetch
+        run: time ./flashfetch
+
+      - name: Run ldd
+        run: ldd fastfetch
+
+      - name: Run tests
+        run: ctest --output-on-failure
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: fastfetch-netbsd-amd64
+          path: ./fastfetch-*.*

.github/workflows/build-no-features-test.yml

@@ -0,0 +1,45 @@
+name: Reusable No Features Test
+
+on:
+  workflow_call:
+
+permissions:
+  contents: read
+
+env:
+  CMAKE_BUILD_TYPE: ${{ vars.CMAKE_BUILD_TYPE || 'RelWithDebInfo' }}
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: uname -a
+        run: uname -a
+
+      - name: configure project
+        run: cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DCMAKE_INSTALL_PREFIX=/usr . -DENABLE_VULKAN=OFF -DENABLE_WAYLAND=OFF -DENABLE_XCB_RANDR=OFF -DENABLE_XCB=OFF -DENABLE_XRANDR=OFF -DENABLE_X11=OFF -DENABLE_DRM=OFF -DENABLE_DRM_AMDGPU=OFF -DENABLE_GIO=OFF -DENABLE_DCONF=OFF -DENABLE_DBUS=OFF -DENABLE_SQLITE3=OFF -DENABLE_RPM=OFF -DENABLE_IMAGEMAGICK7=OFF -DENABLE_IMAGEMAGICK6=OFF -DENABLE_CHAFA=OFF -DENABLE_ZLIB=OFF -DENABLE_EGL=OFF -DENABLE_GLX=OFF -DENABLE_OPENCL=OFF -DENABLE_FREETYPE=OFF -DENABLE_PULSE=OFF -DENABLE_DDCUTIL=OFF -DENABLE_ELF=OFF -DENABLE_EET=OFF -DENABLE_THREADS=OFF
+
+      - name: build project
+        run: cmake --build . --target package --verbose -j4
+
+      - name: list features
+        run: ./fastfetch --list-features
+
+      - name: run fastfetch
+        run: time ./fastfetch -c presets/ci.jsonc --stat false
+
+      - name: run fastfetch --format json
+        run: time ./fastfetch -c presets/ci.jsonc --format json
+
+      - name: run flashfetch
+        run: time ./flashfetch
+
+      - name: print dependencies
+        run: ldd fastfetch
+
+      - name: run tests
+        run: ctest --output-on-failure

.github/workflows/build-omnios-amd64.yml

@@ -0,0 +1,70 @@
+name: Reusable OmniOS amd64
+
+on:
+  workflow_call:
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        shell: cpa.sh {0}
+
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: Start VM
+        uses: cross-platform-actions/action@faa0c6197e94aacf1c5956460152c8380d3560a5 # v1.5.0
+        with:
+          operating_system: omnios
+          version: 'r151058'
+          shell: bash
+          cpu_count: 4
+
+      - name: Show system info
+        run: |
+          uname -a
+
+      - name: Update and install dependencies
+        run: |
+          sudo pkg update --accept || true
+          sudo pkg install gcc14 cmake git pkg-config glib2 dbus sqlite-3 imagemagick ninja
+
+      - name: CMake configuration
+        run: cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -GNinja -DENABLE_EMBEDDED_PCIIDS=On -DENABLE_EMBEDDED_AMDGPUIDS=On -DCMAKE_BUILD_TYPE=${{ vars.CMAKE_BUILD_TYPE || 'RelWithDebInfo' }} .
+
+      - name: CMake build
+        run: cmake --build . --verbose -j4
+
+      - name: List features
+        run: ./fastfetch --list-features
+
+      - name: Run normal
+        run: time ./fastfetch -c presets/ci.jsonc --stat false
+
+      - name: Run json
+        run: time ./fastfetch -c presets/ci.jsonc --format json
+
+      - name: Run flashfetch
+        run: time ./flashfetch
+
+      - name: Run ldd
+        run: ldd fastfetch
+
+      - name: Run tests
+        run: ctest --output-on-failure
+
+      - name: Package
+        run: |
+          echo 'set(CPACK_PACKAGE_FILE_NAME "fastfetch-omnios-amd64")' >> CPackConfig.cmake
+          cpack -V
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: fastfetch-omnios-amd64
+          path: ./fastfetch-*.*

.github/workflows/build-openbsd-amd64.yml

@@ -0,0 +1,65 @@
+name: Reusable OpenBSD amd64
+
+on:
+  workflow_call:
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        shell: cpa.sh {0}
+
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: Start VM
+        uses: cross-platform-actions/action@faa0c6197e94aacf1c5956460152c8380d3560a5 # v1.5.0
+        with:
+          operating_system: openbsd
+          version: '7.9'
+          shell: bash
+          cpu_count: 4
+
+      - name: Show system info
+        run: |
+          uname -a
+
+      - name: Update and install dependencies
+        run: |
+          sudo pkg_add -u
+          sudo pkg_add -r llvm-21.1.8p4 cmake git wayland vulkan-headers vulkan-loader glib2 dconf dbus sqlite3 imagemagick chafa lua-5.4.8p0 # pkg-config is preinstalled
+
+      - name: CMake configuration
+        run: CC=clang-21 cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DENABLE_EMBEDDED_PCIIDS=On -DENABLE_EMBEDDED_AMDGPUIDS=On -DCMAKE_BUILD_TYPE=${{ vars.CMAKE_BUILD_TYPE || 'RelWithDebInfo' }} .
+
+      - name: CMake build
+        run: cmake --build . --target package --verbose -j4
+
+      - name: List features
+        run: ./fastfetch --list-features
+
+      - name: Run normal
+        run: time ./fastfetch -c presets/ci.jsonc --stat false
+
+      - name: Run json
+        run: time ./fastfetch -c presets/ci.jsonc --format json
+
+      - name: Run flashfetch
+        run: time ./flashfetch
+
+      - name: Run ldd
+        run: ldd fastfetch
+
+      - name: Run tests
+        run: ctest --output-on-failure
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: fastfetch-openbsd-amd64
+          path: ./fastfetch-*.*

.github/workflows/build-release.yml

@@ -0,0 +1,61 @@
+name: Reusable Release
+
+on:
+  workflow_call:
+    inputs:
+      ffversion:
+        required: true
+        type: string
+
+permissions:
+  contents: write
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - name: get latest release version
+        id: get_version_release
+        uses: pozetroninc/github-action-get-latest-release@2a61c339ea7ef0a336d1daa35ef0cb1418e7676c # v0.8.0
+        with:
+          repository: ${{ github.repository }}
+
+      - name: download artifacts
+        if: inputs.ffversion != steps.get_version_release.outputs.release
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+
+      - name: create release
+        if: inputs.ffversion != steps.get_version_release.outputs.release
+        uses: ncipollo/release-action@339a81892b84b4eeb0f6e744e4574d79d0d9b8dd # v1.21.0
+        with:
+          tag: ${{ inputs.ffversion }}
+          commit: ${{ github.sha }}
+          artifactErrorsFailBuild: true
+          artifacts: fastfetch-*/fastfetch-*
+          body: "Please refer to [CHANGELOG.md](https://github.com/${{ github.repository }}/blob/${{ inputs.ffversion }}/CHANGELOG.md) for details."
+
+      - name: download source tarballs
+        if: inputs.ffversion != steps.get_version_release.outputs.release
+        run: |
+          for i in 1 2 3 4 5; do curl -L --remote-name-all --output-dir fastfetch-source --create-dirs https://github.com/${{ github.repository }}/archive/refs/tags/${{ inputs.ffversion }}.{tar.gz,zip} && break || sleep 5; done
+          ls fastfetch-*/*
+
+      - name: generate release notes
+        if: inputs.ffversion != steps.get_version_release.outputs.release
+        run: |
+          echo "Please refer to [CHANGELOG.md](https://github.com/${{ github.repository }}/blob/${{ inputs.ffversion }}/CHANGELOG.md) for details." > fastfetch-release-notes.md
+          echo -e "\n---\n\n<details><summary>SHA256SUMs</summary><br>\n\n\`\`\`" >> fastfetch-release-notes.md
+          sha256sum fastfetch-*/* >> fastfetch-release-notes.md
+          echo -e "\`\`\`\n</details>" >> fastfetch-release-notes.md
+          echo -e "\n<details><summary>SHA512SUMs</summary><br>\n\n\`\`\`" >> fastfetch-release-notes.md
+          sha512sum fastfetch-*/* >> fastfetch-release-notes.md
+          echo -e "\`\`\`\n</details>" >> fastfetch-release-notes.md
+
+      - name: update release body
+        if: inputs.ffversion != steps.get_version_release.outputs.release
+        uses: ncipollo/release-action@339a81892b84b4eeb0f6e744e4574d79d0d9b8dd # v1.21.0
+        with:
+          tag: ${{ inputs.ffversion }}
+          commit: ${{ github.sha }}
+          bodyFile: fastfetch-release-notes.md
+          allowUpdates: true

.github/workflows/build-solaris-amd64.yml

@@ -0,0 +1,46 @@
+name: Reusable Solaris amd64
+
+on:
+  workflow_call:
+
+permissions:
+  contents: read
+
+env:
+  CMAKE_BUILD_TYPE: ${{ vars.CMAKE_BUILD_TYPE || 'RelWithDebInfo' }}
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: run VM
+        uses: vmactions/solaris-vm@315163f088b66e55bbcc45928bd224d4973b2312 # v1.3.8
+        with:
+          usesh: true
+          envs: 'CMAKE_BUILD_TYPE'
+          release: "11.4-gcc-14"
+          prepare: |
+            uname -a
+            pkg install cmake git pkg-config glib2 dbus sqlite-3 imagemagick ninja dconf mesa lua
+
+          run: |
+            export PKG_CONFIG_PATH=/usr/lib/64/pkgconfig
+            cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -GNinja .
+            cmake --build . --verbose -j4
+            ./fastfetch --list-features
+            time ./fastfetch -c presets/ci.jsonc --stat false
+            time ./fastfetch -c presets/ci.jsonc --format json
+            time ./flashfetch
+            ldd fastfetch
+            ctest --output-on-failure
+            echo 'set(CPACK_PACKAGE_FILE_NAME "fastfetch-solaris-amd64")' >> CPackConfig.cmake
+            cpack -V
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: fastfetch-solaris-amd64
+          path: ./fastfetch-*.*

.github/workflows/build-spellcheck.yml

@@ -0,0 +1,24 @@
+name: Reusable Spellcheck
+
+on:
+  workflow_call:
+
+permissions:
+  contents: read
+
+jobs:
+  spellcheck:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: Install codespell
+        shell: bash
+        run: |
+          pip3 install codespell
+          codespell --version
+
+      - name: Run Spellchecker
+        run: codespell

.github/workflows/build-windows-hosts.yml

@@ -0,0 +1,146 @@
+name: Reusable Windows Hosts
+
+on:
+  workflow_call:
+    inputs:
+      arch:
+        required: true
+        type: string
+      runs-on:
+        required: true
+        type: string
+      msystem:
+        required: true
+        type: string
+      msystem-lower:
+        required: true
+        type: string
+      msys-arch:
+        required: true
+        type: string
+    secrets:
+      SIGNPATH_API_TOKEN:
+        description: SignPath REST API token used to submit the signing request
+        # Optional so that runs without the secret (pull requests, forks)
+        # still work; the signing step is skipped there anyway.
+        required: false
+
+permissions:
+  contents: read
+  # The SignPath action reads job details and downloads the unsigned
+  # artifact with the workflow token.
+  actions: read
+
+env:
+  CMAKE_BUILD_TYPE: ${{ vars.CMAKE_BUILD_TYPE || 'RelWithDebInfo' }}
+
+jobs:
+  build:
+    runs-on: ${{ inputs.runs-on }}
+    defaults:
+      run:
+        shell: msys2 {0}
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: setup-msys2
+        uses: msys2/setup-msys2@66cd2cce69caa17b53920067426061ca1de3a884 # v2.32.0
+        with:
+          msystem: ${{ inputs.msystem }}
+          update: true
+          install: git mingw-w64-clang-${{ inputs.msys-arch }}-7zip mingw-w64-clang-${{ inputs.msys-arch }}-cmake mingw-w64-clang-${{ inputs.msys-arch }}-clang mingw-w64-clang-${{ inputs.msys-arch }}-jq mingw-w64-clang-${{ inputs.msys-arch }}-vulkan-loader mingw-w64-clang-${{ inputs.msys-arch }}-vulkan-headers mingw-w64-clang-${{ inputs.msys-arch }}-opencl-icd mingw-w64-clang-${{ inputs.msys-arch }}-opencl-headers mingw-w64-clang-${{ inputs.msys-arch }}-cppwinrt mingw-w64-clang-${{ inputs.msys-arch }}-imagemagick mingw-w64-clang-${{ inputs.msys-arch }}-chafa mingw-w64-clang-${{ inputs.msys-arch }}-lua mingw-w64-clang-${{ inputs.msys-arch }}-quickjs-ng mingw-w64-clang-${{ inputs.msys-arch }}-directx-headers
+
+      - name: print msys version
+        run: uname -a
+
+      - name: configure project
+        run: env PKG_CONFIG_PATH=/${{ inputs.msystem-lower }}/lib/pkgconfig/:$PKG_CONFIG_PATH cmake -DSET_TWEAK=Off -DBUILD_TESTS=On .
+
+      - name: build project
+        run: cmake --build . --verbose -j4
+
+      - name: copy necessary dlls
+        run: cp /${{ inputs.msystem-lower }}/bin/{lua55,libqjs-0}.dll .
+
+      - name: list features
+        run: ./fastfetch --list-features
+
+      - name: run fastfetch
+        run: time ./fastfetch -c presets/ci.jsonc --stat false
+
+      - name: run fastfetch --format json
+        run: |
+          { time -p ./fastfetch -c presets/ci.jsonc --format json > fastfetch.raw.json 2> fastfetch.error; } 2> fastfetch.time
+          sed -n '/^[[:space:]]*\[/,$p' fastfetch.raw.json > fastfetch.json
+          cat fastfetch.json
+          cat fastfetch.error >&2
+          cat fastfetch.time >&2
+
+      - name: prepare benchmark data
+        run: |
+          real_seconds=$(awk '$1 == "real" { print $2 }' fastfetch.time)
+          jq -e 'type == "array"' fastfetch.json > /dev/null
+          jq --arg platform "windows" --arg arch "${{ inputs.arch }}" --argjson real_seconds "$real_seconds" '
+            map(select(.stat | type == "number") | {
+              name: ("fastfetch " + $platform + " " + $arch + " module " + .type),
+              unit: "ms",
+              value: .stat
+            }) + [{
+              name: ("fastfetch " + $platform + " " + $arch + " total process time"),
+              unit: "ms",
+              value: ($real_seconds * 1000)
+            }]
+          ' fastfetch.json > benchmark.json
+          cat benchmark.json
+
+      - name: run flashfetch
+        run: time ./flashfetch
+
+      - name: print dependencies
+        run: ldd fastfetch
+
+      - name: run tests
+        run: ctest --output-on-failure
+
+      - if: github.event_name == 'push' && github.repository == 'fastfetch-cli/fastfetch'
+        id: upload-unsigned-artifact
+        name: upload artifacts for signing
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: fastfetch-windows-${{ inputs.arch }}
+          path: |
+            *.dll
+            fastfetch.exe
+            flashfetch.exe
+
+      - if: github.event_name == 'push' && github.repository == 'fastfetch-cli/fastfetch'
+        name: submit signing request
+        uses: signpath/github-action-submit-signing-request@c92b958760219087e01f8d67a1669ed57afe2627 # v2.3
+        with:
+          api-token: '${{ secrets.SIGNPATH_API_TOKEN }}'
+          organization-id: '${{ vars.SIGNPATH_ORG_ID }}'
+          project-slug: 'fastfetch'
+          signing-policy-slug: ${{ github.ref == 'refs/heads/master' && 'release-signing' || 'test-signing' }}
+          github-artifact-id: '${{ steps.upload-unsigned-artifact.outputs.artifact-id }}'
+          wait-for-completion: true
+          output-artifact-directory: '.'
+
+      - name: create zip archive
+        run: 7z a -tzip -mx9 -bd -y fastfetch-windows-${{ inputs.arch }}.zip LICENSE *.dll fastfetch.exe flashfetch.exe presets
+
+      - name: create 7z archive
+        run: 7z a -t7z -mx9 -bd -y fastfetch-windows-${{ inputs.arch }}.7z LICENSE *.dll fastfetch.exe flashfetch.exe presets
+
+      - name: upload true artifacts
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: fastfetch-windows-${{ inputs.arch }}
+          path: ./fastfetch-windows-${{ inputs.arch }}.*
+          overwrite: true
+
+      - name: upload benchmark data
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: benchmark-windows-${{ inputs.arch }}
+          path: benchmark.json

.github/workflows/ci.yml

@@ -4,66 +4,22 @@ on:
   - push
   - pull_request
 
-env:
-  CMAKE_BUILD_TYPE: ${{ vars.CMAKE_BUILD_TYPE || 'RelWithDebInfo' }}
-
 jobs:
   spellcheck:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: checkout repository
-        uses: actions/checkout@v6
-
-      - name: Install codespell
-        shell: bash
-        run: |
-          sudo apt-get update || true
-          sudo apt-get install -y codespell
-
-      - name: Run Spellchecker
-        run: codespell
+    permissions:
+      contents: read
+    uses: ./.github/workflows/build-spellcheck.yml
 
   no-features-test:
+    needs: spellcheck
     name: No-features-test
-    runs-on: ubuntu-latest
     permissions:
-      security-events: write
       contents: read
-    steps:
-      - name: checkout repository
-        uses: actions/checkout@v6
-
-      - name: uname -a
-        run: uname -a
-
-      - name: configure project
-        run: cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DCMAKE_INSTALL_PREFIX=/usr . -DENABLE_VULKAN=OFF -DENABLE_WAYLAND=OFF -DENABLE_XCB_RANDR=OFF -DENABLE_XCB=OFF -DENABLE_XRANDR=OFF -DENABLE_X11=OFF -DENABLE_DRM=OFF -DENABLE_DRM_AMDGPU=OFF -DENABLE_GIO=OFF -DENABLE_DCONF=OFF -DENABLE_DBUS=OFF -DENABLE_SQLITE3=OFF -DENABLE_RPM=OFF -DENABLE_IMAGEMAGICK7=OFF -DENABLE_IMAGEMAGICK6=OFF -DENABLE_CHAFA=OFF -DENABLE_ZLIB=OFF -DENABLE_EGL=OFF -DENABLE_GLX=OFF -DENABLE_OPENCL=OFF -DENABLE_FREETYPE=OFF -DENABLE_PULSE=OFF -DENABLE_DDCUTIL=OFF -DENABLE_ELF=OFF -DENABLE_DIRECTX_HEADERS=OFF -DENABLE_THREADS=OFF
-
-      - name: build project
-        run: cmake --build . --target package --verbose -j4
-
-      - name: list features
-        run: ./fastfetch --list-features
-
-      - name: run fastfetch
-        run: time ./fastfetch -c presets/ci.jsonc --stat false
-
-      - name: run fastfetch --format json
-        run: time ./fastfetch -c presets/ci.jsonc --format json
-
-      - name: run flashfetch
-        run: time ./flashfetch
-
-      - name: print dependencies
-        run: ldd fastfetch
-
-      - name: run tests
-        run: ctest --output-on-failure
+    uses: ./.github/workflows/build-no-features-test.yml
 
   linux-hosts:
+    needs: no-features-test
     name: Linux-${{ matrix.arch }}
-    runs-on: ${{ matrix.runs-on }}
     permissions:
       security-events: write
       contents: read
@@ -74,235 +30,36 @@ jobs:
             runs-on: ubuntu-22.04
           - arch: aarch64
             runs-on: ubuntu-22.04-arm
-    outputs:
-      ffversion: ${{ steps.ffversion.outputs.ffversion }}
-    steps:
-      - name: checkout repository
-        uses: actions/checkout@v6
-
-      - name: uname -a
-        run: uname -a
-
-      - name: cat /etc/os-release
-        run: cat /etc/os-release
-
-      - name: cat /proc/cpuinfo
-        run: cat /proc/cpuinfo
-
-      - name: add gcc-13 repo
-        run: sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
-
-      - name: install required packages
-        run: sudo apt-get update && sudo apt-get install -y gcc-13 g++-13 libvulkan-dev libwayland-dev libxrandr-dev libxcb-randr0-dev libdconf-dev libdbus-1-dev libmagickcore-dev libsqlite3-dev librpm-dev libegl-dev libglx-dev ocl-icd-opencl-dev libpulse-dev libdrm-dev libelf-dev libddcutil-dev directx-headers-dev rpm ninja-build
-
-      - name: install linuxbrew packages
-        run: |
-          /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
-          /home/linuxbrew/.linuxbrew/bin/brew install imagemagick chafa --ignore-dependencies
-
-      - name: Initialize CodeQL
-        if: matrix.arch == 'amd64'
-        uses: github/codeql-action/init@v4
-        with:
-          languages: c
-
-      - name: configure project
-        run: CC=gcc-13 CXX=g++-13 PKG_CONFIG_PATH=/home/linuxbrew/.linuxbrew/lib/pkgconfig:$PKG_CONFIG_PATH cmake -GNinja -DSET_TWEAK=Off -DBUILD_TESTS=On -DENABLE_EMBEDDED_PCIIDS=On -DENABLE_EMBEDDED_AMDGPUIDS=On -DCMAKE_INSTALL_PREFIX=/usr .
-
-      - name: build project
-        run: cmake --build . --target package --verbose -j4
-
-      - name: perform CodeQL analysis
-        if: matrix.arch == 'amd64'
-        uses: github/codeql-action/analyze@v4
-
-      - name: list features
-        run: ./fastfetch --list-features
-
-      - name: run fastfetch
-        run: time ./fastfetch -c presets/ci.jsonc --stat false
-
-      - name: run fastfetch --format json
-        run: time ./fastfetch -c presets/ci.jsonc --format json
-
-      - name: run flashfetch
-        run: time ./flashfetch
-
-      - name: print dependencies
-        run: ldd fastfetch
-
-      - name: run tests
-        run: ctest --output-on-failure
-
-      - name: get fastfetch version
-        id: ffversion
-        run: echo "ffversion=$(./fastfetch --version-raw)" >> $GITHUB_OUTPUT
-
-      - name: polyfill glibc
-        run: |
-          wget https://github.com/CarterLi/polyfill-glibc/releases/download/v0.0.1/polyfill-glibc-${{ matrix.arch }} -O polyfill-glibc
-          chmod +x polyfill-glibc
-          strip fastfetch && ./polyfill-glibc fastfetch --target-glibc=2.17
-          strip flashfetch && ./polyfill-glibc flashfetch --target-glibc=2.17
-          echo 'set(CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_FILE_NAME}-polyfilled")' >> CPackConfig.cmake
-          echo 'set(CPACK_PACKAGE_RELOCATABLE OFF)' >> CPackConfig.cmake
-          echo 'set(CPACK_DEBIAN_PACKAGE_DEPENDS "libc6 (>= 2.17)")' >> CPackConfig.cmake
-          echo 'set(CPACK_RPM_SPEC_MORE_DEFINE "%global __os_install_post %{nil}")' >> CPackConfig.cmake
-          cpack -V
-
-      - name: upload artifacts
-        uses: actions/upload-artifact@v7
-        with:
-          name: fastfetch-linux-${{ matrix.arch }}
-          path: ./fastfetch-*.*
+    uses: ./.github/workflows/build-linux-hosts.yml
+    with:
+      arch: ${{ matrix.arch }}
+      runs-on: ${{ matrix.runs-on }}
 
   linux-i686:
+    needs: no-features-test
     name: Linux-i686
-    runs-on: ubuntu-22.04
     permissions:
-      security-events: write
       contents: read
-    steps:
-      - name: checkout repository
-        uses: actions/checkout@v6
-
-      - name: uname -a
-        run: uname -a
-
-      - name: cat /etc/os-release
-        run: cat /etc/os-release
-
-      - name: cat /proc/cpuinfo
-        run: cat /proc/cpuinfo
-
-      - name: add gcc-13 repo
-        run: sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
-
-      - name: install required packages
-        run: sudo apt-get update && sudo apt-get install -y gcc-13 gcc-13-multilib libvulkan-dev libwayland-dev libxrandr-dev libxcb-randr0-dev libdconf-dev libdbus-1-dev libmagickcore-dev libsqlite3-dev librpm-dev libegl-dev libglx-dev ocl-icd-opencl-dev libpulse-dev libdrm-dev libelf-dev libddcutil-dev rpm ninja-build
-
-      - name: install linuxbrew packages
-        run: |
-          /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
-          /home/linuxbrew/.linuxbrew/bin/brew install imagemagick chafa --ignore-dependencies
-
-      - name: cmake version
-        run: cmake --version
-
-      - name: configure project
-        run: CC=gcc-13 PKG_CONFIG_PATH=/home/linuxbrew/.linuxbrew/lib/pkgconfig:$PKG_CONFIG_PATH cmake -DCMAKE_C_FLAGS="-m32 -march=i686 -mtune=i686" -DCMAKE_SYSTEM_PROCESSOR_OVERRIDE=i686 -DCPACK_DEBIAN_PACKAGE_ARCHITECTURE=i386 -GNinja -DSET_TWEAK=Off -DBUILD_TESTS=On -DENABLE_EMBEDDED_PCIIDS=On -DENABLE_EMBEDDED_AMDGPUIDS=On -DCMAKE_INSTALL_PREFIX=/usr -DENABLE_DIRECTX_HEADERS=Off .
-
-      - name: build project
-        run: cmake --build . --target package --verbose -j4
-
-      - name: check deb package
-        run: dpkg -I fastfetch-*.deb
-
-      - name: list features
-        run: ./fastfetch --list-features
-
-      - name: run fastfetch
-        run: time ./fastfetch -c presets/ci.jsonc --stat false
-
-      - name: run fastfetch --format json
-        run: time ./fastfetch -c presets/ci.jsonc --format json
-
-      - name: run flashfetch
-        run: time ./flashfetch
-
-      - name: print dependencies
-        run: ldd fastfetch
-
-      - name: run tests
-        run: ctest --output-on-failure
-
-      - name: upload artifacts
-        uses: actions/upload-artifact@v7
-        with:
-          name: fastfetch-linux-i686
-          path: ./fastfetch-*.*
+    uses: ./.github/workflows/build-linux-i686.yml
 
   linux-armv7l:
+    needs: no-features-test
     name: Linux-armv7l
-    runs-on: ubuntu-24.04
     permissions:
-      security-events: write
       contents: read
-    steps:
-      - name: checkout repository
-        uses: actions/checkout@v6
+    uses: ./.github/workflows/build-linux-armv7l.yml
 
-      - name: run VM
-        uses: uraimo/run-on-arch-action@v3
-        id: runcmd
-        with:
-          arch: armv7
-          distro: ubuntu20.04
-          githubToken: ${{ github.token }}
-          run: |
-            uname -a
-            apt-get update && apt-get install -y software-properties-common ca-certificates gpg curl
-            add-apt-repository -y ppa:ubuntu-toolchain-r/test
-            curl -L https://apt.kitware.com/keys/kitware-archive-latest.asc | gpg --dearmor - | tee /usr/share/keyrings/kitware-archive-keyring.gpg >/dev/null
-            echo 'deb [signed-by=/usr/share/keyrings/kitware-archive-keyring.gpg] https://apt.kitware.com/ubuntu/ focal main' | tee /etc/apt/sources.list.d/kitware.list >/dev/null
-            echo -e 'Acquire::https::Verify-Peer "false";\nAcquire::https::Verify-Host "false";' >> /etc/apt/apt.conf.d/99ignore-certificates
-            apt-get update && apt-get install -y cmake make gcc-13 libvulkan-dev libwayland-dev libxrandr-dev libxcb-randr0-dev libdconf-dev libdbus-1-dev libmagickcore-dev libsqlite3-dev librpm-dev libegl-dev libglx-dev ocl-icd-opencl-dev libpulse-dev libdrm-dev libelf-dev rpm
-            CC=gcc-13 cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DENABLE_DIRECTX_HEADERS=Off -DCMAKE_INSTALL_PREFIX=/usr .
-            cmake --build . --target package --verbose -j4
-            ./fastfetch --list-features
-            time ./fastfetch -c presets/ci.jsonc --stat false
-            time ./fastfetch -c presets/ci.jsonc --format json
-            time ./flashfetch
-            ldd fastfetch
-            ctest --output-on-failure
-
-      - name: upload artifacts
-        uses: actions/upload-artifact@v7
-        with:
-          name: fastfetch-linux-armv7l
-          path: ./fastfetch-*.*
-
-  linux-armv6l:
-    name: Linux-armv6l
-    runs-on: ubuntu-24.04
+  linux-loong64:
+    needs: no-features-test
+    name: Linux-loong64
     permissions:
-      security-events: write
       contents: read
-    steps:
-      - name: checkout repository
-        uses: actions/checkout@v6
-
-      - name: run VM
-        uses: uraimo/run-on-arch-action@v3
-        id: runcmd
-        with:
-          arch: armv6
-          distro: bookworm
-          githubToken: ${{ github.token }}
-          run: |
-            uname -a
-            apt-get update && apt-get install -y wget
-            apt-get install -y cmake make gcc libvulkan-dev libwayland-dev libxrandr-dev libxcb-randr0-dev libdconf-dev libdbus-1-dev libmagickcore-dev libsqlite3-dev librpm-dev libegl-dev libglx-dev ocl-icd-opencl-dev libpulse-dev libdrm-dev libelf-dev rpm
-            cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DENABLE_DIRECTX_HEADERS=Off -DCMAKE_INSTALL_PREFIX=/usr .
-            cmake --build . --target package --verbose -j4
-            ./fastfetch --list-features
-            time ./fastfetch -c presets/ci.jsonc --stat false
-            time ./fastfetch -c presets/ci.jsonc --format json
-            time ./flashfetch
-            ldd fastfetch
-            ctest --output-on-failure
-
-      - name: upload artifacts
-        uses: actions/upload-artifact@v7
-        with:
-          name: fastfetch-linux-armv6l
-          path: ./fastfetch-*.*
+    uses: ./.github/workflows/build-linux-loong64.yml
 
   linux-vms:
+    needs: no-features-test
     name: Linux-${{ matrix.arch }}
-    runs-on: ubuntu-latest
     permissions:
-      security-events: write
       contents: read
     strategy:
       matrix:
@@ -310,80 +67,21 @@ jobs:
           - arch: riscv64
           - arch: ppc64le
           - arch: s390x
-    steps:
-      - name: checkout repository
-        uses: actions/checkout@v6
-
-      - name: run VM
-        uses: uraimo/run-on-arch-action@v3
-        id: runcmd
-        with:
-          arch: ${{ matrix.arch }}
-          distro: ubuntu22.04
-          githubToken: ${{ github.token }}
-          run: |
-            uname -a
-            apt-get update && apt-get install -y software-properties-common
-            add-apt-repository -y ppa:ubuntu-toolchain-r/test
-            apt-get update && apt-get install -y cmake make gcc-13 libvulkan-dev libwayland-dev libxrandr-dev libxcb-randr0-dev libdconf-dev libdbus-1-dev libmagickcore-dev libsqlite3-dev librpm-dev libegl-dev libglx-dev ocl-icd-opencl-dev libpulse-dev libdrm-dev libchafa-dev libelf-dev rpm
-            CC=gcc-13 cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DENABLE_DIRECTX_HEADERS=Off -DCMAKE_INSTALL_PREFIX=/usr .
-            cmake --build . --target package --verbose -j4
-            ./fastfetch --list-features
-            time ./fastfetch -c presets/ci.jsonc --stat false
-            time ./fastfetch -c presets/ci.jsonc --format json
-            time ./flashfetch
-            ldd fastfetch
-            ctest --output-on-failure
-
-      - name: upload artifacts
-        uses: actions/upload-artifact@v7
-        with:
-          name: fastfetch-linux-${{ matrix.arch }}
-          path: ./fastfetch-*.*
+    uses: ./.github/workflows/build-linux-vms.yml
+    with:
+      arch: ${{ matrix.arch }}
 
   musl-amd64:
+    needs: no-features-test
     name: Musl-amd64
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-
-      - name: setup alpine linux
-        uses: jirutka/setup-alpine@master
-
-      - name: install dependencies
-        run: |
-          cat /etc/alpine-release
-          uname -a
-          apk add cmake samurai vulkan-loader-dev libxcb-dev libxrandr-dev rpm-dev wayland-dev libdrm-dev dconf-dev imagemagick-dev chafa-dev zlib-dev dbus-dev mesa-dev opencl-dev sqlite-dev networkmanager-dev pulseaudio-dev ddcutil-dev elfutils-dev gcc g++
-        shell: alpine.sh --root {0}
-
-      - name: build
-        run: |
-            cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DCMAKE_INSTALL_PREFIX=/usr -DIS_MUSL=ON -DENABLE_EMBEDDED_PCIIDS=On -DENABLE_EMBEDDED_AMDGPUIDS=On -GNinja .
-            cmake --build . --target package --verbose -j4
-        shell: alpine.sh {0}
-
-      - name: run
-        run: |
-            ./fastfetch --list-features
-            time ./fastfetch -c presets/ci.jsonc --stat false
-            time ./fastfetch -c presets/ci.jsonc --format json
-            time ./flashfetch
-            ldd fastfetch
-            ctest --output-on-failure
-        shell: alpine.sh {0}
-
-      - name: upload artifacts
-        uses: actions/upload-artifact@v7
-        with:
-          name: fastfetch-musl-amd64
-          path: ./fastfetch-*.*
+    permissions:
+      contents: read
+    uses: ./.github/workflows/build-musl-amd64.yml
 
   macos-hosts:
+    needs: no-features-test
     name: macOS-${{ matrix.arch }}
-    runs-on: ${{ matrix.runs-on }}
     permissions:
-      security-events: write
       contents: read
     strategy:
       matrix:
@@ -392,309 +90,68 @@ jobs:
             runs-on: macos-15-intel
           - arch: aarch64
             runs-on: macos-latest
-    steps:
-      - name: checkout repository
-        uses: actions/checkout@v6
-
-      - name: uname -a
-        run: uname -a
-
-      - name: install required packages
-        run: |
-          HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK=1 brew install --overwrite vulkan-loader vulkan-headers molten-vk imagemagick chafa
-
-      - name: configure project
-        run: cmake -DSET_TWEAK=Off -DBUILD_TESTS=On .
-
-      - name: build project
-        run: cmake --build . --target package --verbose -j4
-
-      - name: list features
-        run: ./fastfetch --list-features
-
-      - name: run fastfetch
-        run: time ./fastfetch -c presets/ci.jsonc --stat false
-
-      - name: run fastfetch --format json
-        run: time ./fastfetch -c presets/ci.jsonc --format json
-
-      - name: run flashfetch
-        run: time ./flashfetch
-
-      - name: print dependencies
-        run: otool -L fastfetch
-
-      - name: run tests
-        run: ctest --output-on-failure
-
-      - name: upload artifacts
-        uses: actions/upload-artifact@v7
-        with:
-          name: fastfetch-macos-${{ matrix.arch }}
-          path: ./fastfetch-*.*
+    uses: ./.github/workflows/build-macos-hosts.yml
+    with:
+      arch: ${{ matrix.arch }}
+      runs-on: ${{ matrix.runs-on }}
 
   omnios-amd64:
-    runs-on: ubuntu-latest
+    needs: no-features-test
     name: OmniOS-amd64
-    steps:
-      - name: checkout repository
-        uses: actions/checkout@v6
-
-      - name: run VM
-        uses: vmactions/omnios-vm@v1
-        with:
-          usesh: true
-          envs: 'CMAKE_BUILD_TYPE'
-          prepare: |
-            uname -a
-            pkg update --accept
-            pkg install gcc14 cmake git pkg-config glib2 dbus sqlite-3 imagemagick ninja
-
-          run: |
-            cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -GNinja .
-            cmake --build . --verbose -j4
-            ./fastfetch --list-features
-            time ./fastfetch -c presets/ci.jsonc --stat false
-            time ./fastfetch -c presets/ci.jsonc --format json
-            time ./flashfetch
-            ldd fastfetch
-            ctest --output-on-failure
-            echo 'set(CPACK_PACKAGE_FILE_NAME "fastfetch-omnios-amd64")' >> CPackConfig.cmake
-            cpack -V
-
-      - name: upload artifacts
-        uses: actions/upload-artifact@v7
-        with:
-          name: fastfetch-omnios-amd64
-          path: ./fastfetch-*.*
+    permissions:
+      contents: read
+    uses: ./.github/workflows/build-omnios-amd64.yml
 
   solaris-amd64:
-    runs-on: ubuntu-latest
+    needs: no-features-test
     name: Solaris-amd64
-    steps:
-      - name: checkout repository
-        uses: actions/checkout@v6
-
-      - name: run VM
-        uses: vmactions/solaris-vm@v1
-        with:
-          usesh: true
-          envs: 'CMAKE_BUILD_TYPE'
-          release: "11.4-gcc-14"
-          prepare: |
-            uname -a
-            pkg install cmake git pkg-config glib2 dbus sqlite-3 imagemagick ninja dconf mesa
-
-          run: |
-            export PKG_CONFIG_PATH=/usr/lib/64/pkgconfig
-            cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -GNinja .
-            cmake --build . --verbose -j4
-            ./fastfetch --list-features
-            time ./fastfetch -c presets/ci.jsonc --stat false
-            time ./fastfetch -c presets/ci.jsonc --format json
-            time ./flashfetch
-            ldd fastfetch
-            ctest --output-on-failure
-            echo 'set(CPACK_PACKAGE_FILE_NAME "fastfetch-solaris-amd64")' >> CPackConfig.cmake
-            cpack -V
-
-      - name: upload artifacts
-        uses: actions/upload-artifact@v7
-        with:
-          name: fastfetch-solaris-amd64
-          path: ./fastfetch-*.*
+    permissions:
+      contents: read
+    uses: ./.github/workflows/build-solaris-amd64.yml
 
   freebsd-amd64:
+    needs: no-features-test
     name: FreeBSD-amd64
-    runs-on: ubuntu-latest
     permissions:
-      security-events: write
       contents: read
-    steps:
-      - name: checkout repository
-        uses: actions/checkout@v6
-
-      - name: run VM
-        uses: cross-platform-actions/action@master
-        with:
-          operating_system: freebsd
-          architecture: x86-64
-          cpu_count: 4
-          shell: bash
-          version: '15.0'
-          environment_variables: 'CMAKE_BUILD_TYPE'
-          run: |
-            uname -a
-            sudo pkg update
-            sudo pkg install -y cmake git pkgconf binutils wayland vulkan-headers vulkan-loader libxcb libXrandr libX11 libdrm glib dconf dbus sqlite3-tcl egl opencl ocl-icd v4l_compat chafa
-            cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DENABLE_EMBEDDED_PCIIDS=On -DENABLE_EMBEDDED_AMDGPUIDS=On .
-            cmake --build . --target package --verbose -j4
-            ./fastfetch --list-features
-            time ./fastfetch -c presets/ci.jsonc --stat false
-            time ./fastfetch -c presets/ci.jsonc --format json
-            time ./flashfetch
-            ldd fastfetch
-            ctest --output-on-failure
-
-      - name: upload artifacts
-        uses: actions/upload-artifact@v7
-        with:
-          name: fastfetch-freebsd-amd64
-          path: ./fastfetch-*.*
+    uses: ./.github/workflows/build-freebsd-amd64.yml
 
   openbsd-amd64:
+    needs: no-features-test
     name: OpenBSD-amd64
-    runs-on: ubuntu-latest
     permissions:
-      security-events: write
       contents: read
-    steps:
-      - name: checkout repository
-        uses: actions/checkout@v6
-
-      - name: run VM
-        uses: cross-platform-actions/action@master
-        with:
-          operating_system: openbsd
-          architecture: x86-64
-          cpu_count: 4
-          shell: bash
-          version: '7.8'
-          environment_variables: 'CMAKE_BUILD_TYPE'
-          run: |
-            uname -a
-            sudo pkg_add -u
-            sudo pkg_add -r llvm-21.1.2p0 cmake git pkgconf wayland vulkan-headers vulkan-loader glib2 dconf dbus sqlite3 imagemagick chafa
-            CC=clang-21 cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DENABLE_EMBEDDED_PCIIDS=On -DENABLE_EMBEDDED_AMDGPUIDS=On .
-            cmake --build . --target package --verbose -j4
-            ./fastfetch --list-features
-            time ./fastfetch -c presets/ci.jsonc --stat false
-            time ./fastfetch -c presets/ci.jsonc --format json
-            time ./flashfetch
-            ldd fastfetch
-            ctest --output-on-failure
-
-      - name: upload artifacts
-        uses: actions/upload-artifact@v7
-        with:
-          name: fastfetch-openbsd-amd64
-          path: ./fastfetch-*.*
+    uses: ./.github/workflows/build-openbsd-amd64.yml
 
   netbsd-amd64:
+    needs: no-features-test
     name: NetBSD-amd64
-    runs-on: ubuntu-latest
     permissions:
-      security-events: write
       contents: read
-    steps:
-      - name: checkout repository
-        uses: actions/checkout@v6
-
-      - name: run VM
-        uses: cross-platform-actions/action@master
-        with:
-          operating_system: netbsd
-          architecture: x86-64
-          cpu_count: 4
-          shell: bash
-          version: '10.1'
-          environment_variables: 'CMAKE_BUILD_TYPE'
-          run: |
-            uname -a
-            sudo pkgin -y install clang cmake git pkgconf wayland vulkan-headers dconf dbus sqlite3 ImageMagick
-            CC=clang cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DENABLE_EMBEDDED_PCIIDS=On -DENABLE_EMBEDDED_AMDGPUIDS=On .
-            cmake --build . --target package --verbose -j4
-            ./fastfetch --list-features
-            time ./fastfetch -c presets/ci.jsonc --stat false
-            time ./fastfetch -c presets/ci.jsonc --format json
-            time ./flashfetch
-            ldd fastfetch
-            ctest --output-on-failure
-
-      - name: upload artifacts
-        uses: actions/upload-artifact@v7
-        with:
-          name: fastfetch-netbsd-amd64
-          path: ./fastfetch-*.*
+    uses: ./.github/workflows/build-netbsd-amd64.yml
 
   dragonfly-amd64:
+    needs: no-features-test
     name: DragonFly-amd64
-    runs-on: ubuntu-latest
     permissions:
-      security-events: write
       contents: read
-    steps:
-      - name: checkout repository
-        uses: actions/checkout@v6
-
-      - name: run VM
-        uses: vmactions/dragonflybsd-vm@v1
-        with:
-          usesh: yes
-          envs: 'CMAKE_BUILD_TYPE'
-          prepare: |
-            uname -a
-            pkg update
-            pkg install -y llvm cmake git pkgconf binutils wayland vulkan-headers vulkan-loader libxcb libXrandr libX11 libdrm glib dconf dbus sqlite3-tcl egl opencl ocl-icd v4l_compat chafa libelf
-
-          run: |
-            env CC=clang cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DENABLE_EMBEDDED_PCIIDS=On -DENABLE_EMBEDDED_AMDGPUIDS=On .
-            cmake --build . --target package --verbose -j4
-            ./fastfetch --list-features
-            time ./fastfetch -c presets/ci.jsonc --stat false
-            time ./fastfetch -c presets/ci.jsonc --format json
-            time ./flashfetch
-            ldd fastfetch
-            ctest --output-on-failure
-
-      - name: upload artifacts
-        uses: actions/upload-artifact@v7
-        with:
-          name: fastfetch-dragonfly-amd64
-          path: ./fastfetch-*.*
+    uses: ./.github/workflows/build-dragonfly-amd64.yml
 
   haiku-amd64:
+    needs: no-features-test
     name: Haiku-amd64
-    runs-on: ubuntu-latest
     permissions:
-      security-events: write
       contents: read
-    steps:
-      - name: checkout repository
-        uses: actions/checkout@v6
-
-      - name: run VM
-        uses: cross-platform-actions/action@master
-        with:
-          operating_system: haiku
-          version: 'r1beta5'
-          architecture: x86-64
-          cpu_count: 4
-          shell: bash
-          environment_variables: 'CMAKE_BUILD_TYPE'
-          run: |
-            uname -a
-            pkgman install -y git dbus_devel mesa_devel libelf_devel imagemagick_devel opencl_headers ocl_icd_devel vulkan_devel zlib_devel chafa_devel cmake gcc make pkgconfig python3.10 || pkgman install -y git dbus_devel mesa_devel libelf_devel imagemagick_devel opencl_headers ocl_icd_devel vulkan_devel zlib_devel chafa_devel cmake gcc make pkgconfig python3.10
-            cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DENABLE_EMBEDDED_PCIIDS=On -DENABLE_EMBEDDED_AMDGPUIDS=On .
-            cmake --build . --target package --verbose -j4
-            ./fastfetch --list-features
-            time ./fastfetch -c presets/ci.jsonc --stat false
-            time ./fastfetch -c presets/ci.jsonc --format json
-            time ./flashfetch
-            ctest --output-on-failure
-
-      - name: upload artifacts
-        uses: actions/upload-artifact@v7
-        with:
-          name: fastfetch-haiku-amd64
-          path: ./fastfetch-*.*
+    uses: ./.github/workflows/build-haiku-amd64.yml
 
   windows-hosts:
-    name: Windows-${{ matrix.arch }}${{ matrix.win7-compat-postfix }}
-    runs-on: ${{ matrix.runs-on }}
+    needs: no-features-test
+    name: Windows-${{ matrix.arch }}
     permissions:
-      security-events: write
       contents: read
+      # The SignPath action reads job details and downloads the unsigned
+      # artifact with the workflow token.
+      actions: read
     strategy:
       matrix:
         include:
@@ -703,111 +160,40 @@ jobs:
             msystem: CLANG64
             msystem-lower: clang64
             msys-arch: x86_64
-            win7-compat-flag: OFF
-            win7-compat-postfix: ""
-          - arch: amd64
-            runs-on: windows-latest
-            msystem: CLANG64
-            msystem-lower: clang64
-            msys-arch: x86_64
-            win7-compat-flag: ON
-            win7-compat-postfix: "-win7"
           - arch: aarch64
             runs-on: windows-11-arm
             msystem: CLANGARM64
             msystem-lower: clangarm64
             msys-arch: aarch64
-            win7-compat-flag: OFF
-            win7-compat-postfix: ""
-    defaults:
-      run:
-        shell: msys2 {0}
-    steps:
-      - name: checkout repository
-        uses: actions/checkout@v6
+    uses: ./.github/workflows/build-windows-hosts.yml
+    with:
+      arch: ${{ matrix.arch }}
+      runs-on: ${{ matrix.runs-on }}
+      msystem: ${{ matrix.msystem }}
+      msystem-lower: ${{ matrix.msystem-lower }}
+      msys-arch: ${{ matrix.msys-arch }}
+    secrets:
+      SIGNPATH_API_TOKEN: ${{ secrets.SIGNPATH_API_TOKEN }}
 
-      - name: setup-msys2
-        uses: msys2/setup-msys2@v2
-        with:
-          msystem: ${{ matrix.msystem }}
-          update: true
-          install: git mingw-w64-clang-${{ matrix.msys-arch }}-7zip mingw-w64-clang-${{ matrix.msys-arch }}-cmake mingw-w64-clang-${{ matrix.msys-arch }}-clang mingw-w64-clang-${{ matrix.msys-arch }}-vulkan-loader mingw-w64-clang-${{ matrix.msys-arch }}-vulkan-headers mingw-w64-clang-${{ matrix.msys-arch }}-opencl-icd mingw-w64-clang-${{ matrix.msys-arch }}-opencl-headers mingw-w64-clang-${{ matrix.msys-arch }}-cppwinrt mingw-w64-clang-${{ matrix.msys-arch }}-imagemagick mingw-w64-clang-${{ matrix.msys-arch }}-chafa
-
-      - name: print msys version
-        run: uname -a
-
-      - name: configure project
-        run: env PKG_CONFIG_PATH=/${{ matrix.msystem-lower }}/lib/pkgconfig/:$PKG_CONFIG_PATH cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DENABLE_WIN7_COMPAT=${{ matrix.win7-compat-flag }} .
-
-      - name: build project
-        run: cmake --build . --verbose -j4
-
-      - name: copy necessary dlls
-        run: cp /${{ matrix.msystem-lower }}/bin/{OpenCL,vulkan-1}.dll .
-
-      - name: list features
-        run: ./fastfetch --list-features
-
-      - name: run fastfetch
-        run: time ./fastfetch -c presets/ci.jsonc --stat false
-
-      - name: run fastfetch --format json
-        run: time ./fastfetch -c presets/ci.jsonc --format json
-
-      - name: run flashfetch
-        run: time ./flashfetch
-
-      - name: print dependencies
-        run: ldd fastfetch
-
-      - name: run tests
-        run: ctest --output-on-failure
-
-      - if: github.event_name == 'push' && github.repository == 'fastfetch-cli/fastfetch'
-        id: upload-unsigned-artifact
-        name: upload artifacts for signing
-        uses: actions/upload-artifact@v7
-        with:
-          name: fastfetch-windows-${{ matrix.arch }}${{ matrix.win7-compat-postfix }}
-          path: |
-            *.dll
-            fastfetch.exe
-            flashfetch.exe
-
-      - if: github.event_name == 'push' && github.repository == 'fastfetch-cli/fastfetch'
-        name: submit signing request
-        uses: signpath/github-action-submit-signing-request@v1
-        with:
-          api-token: '${{ secrets.SIGNPATH_API_TOKEN }}'
-          organization-id: '${{ vars.SIGNPATH_ORG_ID }}'
-          project-slug: 'fastfetch'
-          signing-policy-slug: ${{ github.ref == 'refs/heads/master' && 'release-signing' || 'test-signing' }}
-          github-artifact-id: '${{ steps.upload-unsigned-artifact.outputs.artifact-id }}'
-          wait-for-completion: true
-          output-artifact-directory: '.'
-
-      - name: create zip archive
-        run: 7z a -tzip -mx9 -bd -y fastfetch-windows-${{ matrix.arch }}${{ matrix.win7-compat-postfix }}.zip LICENSE *.dll fastfetch.exe flashfetch.exe presets
-
-      - name: create 7z archive
-        run: 7z a -t7z -mx9 -bd -y fastfetch-windows-${{ matrix.arch }}${{ matrix.win7-compat-postfix }}.7z LICENSE *.dll fastfetch.exe flashfetch.exe presets
-
-      - name: upload true artifacts
-        uses: actions/upload-artifact@v7
-        with:
-          name: fastfetch-windows-${{ matrix.arch }}${{ matrix.win7-compat-postfix }}
-          path: ./fastfetch-windows-${{ matrix.arch }}${{ matrix.win7-compat-postfix }}.*
-          overwrite: true
+  benchmark:
+    if: github.event_name == 'push' && github.ref == 'refs/heads/dev' && github.repository == 'fastfetch-cli/fastfetch'
+    name: Benchmark
+    needs:
+      - linux-hosts
+      - macos-hosts
+      - windows-hosts
+    permissions:
+      contents: write
+    uses: ./.github/workflows/build-benchmark.yml
 
   release:
     if: github.event_name == 'push' && github.ref == 'refs/heads/master' && github.repository == 'fastfetch-cli/fastfetch'
     name: Release
-    runs-on: ubuntu-latest
     needs:
       - linux-hosts
       - linux-i686
       - linux-armv7l
-      - linux-armv6l
+      - linux-loong64
       - linux-vms
       - musl-amd64
       - macos-hosts
@@ -821,49 +207,6 @@ jobs:
       - windows-hosts
     permissions:
       contents: write
-    steps:
-      - name: get latest release version
-        id: get_version_release
-        uses: pozetroninc/github-action-get-latest-release@master
-        with:
-          repository: ${{ github.repository }}
-
-      - name: download artifacts
-        if: needs.linux-hosts.outputs.ffversion != steps.get_version_release.outputs.release
-        uses: actions/download-artifact@v8
-
-      - name: create release
-        if: needs.linux-hosts.outputs.ffversion != steps.get_version_release.outputs.release
-        uses: ncipollo/release-action@v1
-        with:
-          tag: ${{ needs.linux-hosts.outputs.ffversion }}
-          commit: ${{ github.sha }}
-          artifactErrorsFailBuild: true
-          artifacts: fastfetch-*/fastfetch-*
-          body: "Please refer to [CHANGELOG.md](https://github.com/${{ github.repository }}/blob/${{ needs.linux-hosts.outputs.ffversion }}/CHANGELOG.md) for details."
-
-      - name: download source tarballs
-        if: needs.linux-hosts.outputs.ffversion != steps.get_version_release.outputs.release
-        run: |
-          for i in 1 2 3 4 5; do curl -L --remote-name-all --output-dir fastfetch-source --create-dirs https://github.com/${{ github.repository }}/archive/refs/tags/${{ needs.linux-hosts.outputs.ffversion }}.{tar.gz,zip} && break || sleep 5; done
-          ls fastfetch-*/*
-
-      - name: generate release notes
-        if: needs.linux-hosts.outputs.ffversion != steps.get_version_release.outputs.release
-        run: |
-          echo "Please refer to [CHANGELOG.md](https://github.com/${{ github.repository }}/blob/${{ needs.linux-hosts.outputs.ffversion }}/CHANGELOG.md) for details." > fastfetch-release-notes.md
-          echo -e "\n---\n\n<details><summary>SHA256SUMs</summary><br>\n\n\`\`\`" >> fastfetch-release-notes.md
-          sha256sum fastfetch-*/* >> fastfetch-release-notes.md
-          echo -e "\`\`\`\n</details>" >> fastfetch-release-notes.md
-          echo -e "\n<details><summary>SHA512SUMs</summary><br>\n\n\`\`\`" >> fastfetch-release-notes.md
-          sha512sum fastfetch-*/* >> fastfetch-release-notes.md
-          echo -e "\`\`\`\n</details>" >> fastfetch-release-notes.md
-
-      - name: update release body
-        if: needs.linux-hosts.outputs.ffversion != steps.get_version_release.outputs.release
-        uses: ncipollo/release-action@v1
-        with:
-          tag: ${{ needs.linux-hosts.outputs.ffversion }}
-          commit: ${{ github.sha }}
-          bodyFile: fastfetch-release-notes.md
-          allowUpdates: true
+    uses: ./.github/workflows/build-release.yml
+    with:
+      ffversion: ${{ needs.linux-hosts.outputs.ffversion }}

.gitignore

@@ -1,8 +1,10 @@
-build/
-.vs/
-.vscode/
-.cache/
-.kdev4/
+/build/
+/build_*/
+/build-*/
+/.vs/
+/.vscode/
+/.cache/
+/.kdev4/
 .DS_Store
 cscope.*
 tags
@@ -10,3 +12,6 @@ fastfetch.kdev4
 *.user
 *.user.*
 *.swp
+*.log
+/*.zh.md
+/.*-ai/

CHANGELOG.md

@@ -1,3 +1,394 @@
+# 2.68.0
+
+Changes:
+* The DE / WM / LM modules now reports the full name "Desktop Environment" / "Window Manager" / "Login Manager" instead of the abbreviations.
+
+Features:
+* Improved Login Manager (LM) module
+    * Added support on macOS, Windows and POSIX systems without systemd (by process list enumeration).
+    * Reports pretty name on Linux.
+* Added Top module to print processes with the highest CPU, memory or disk I/O usage. (Top)
+* Added module key localization support. (General)
+    * Added a new option `--key-language <?lang>` (`display.key.language: "<?lang>"` in JSON config). When left empty, it defaults to the system locale.
+    * See `fastfetch -h key-language` for all supported languages.
+* Improved Wi-Fi module
+    * Added Wifi channel width detection, exposed via `{channel-width}` in custom format (reports 0 when not supported).
+    * Improved Wifi channel frequency accuracy and fortified detection on Windows, macOS.
+    * Added Wifi detection support on SunOS, Haiku.
+* Added Battery detection support on SunOS. (Battery, SunOS)
+* Added terminal font size detection support on Termux. (TerminalFont, Android)
+* Improved GTK theme/icons/font detection on standalone WMs such as Hyprland, sway, niri and i3. (Theme, Linux)
+* Improved fish completion scripts to print enum descriptions. (Completion)
+* Enabled Wayland support on Android. (DisplayServer, Android)
+* Added DE detection support for ASUS Zenfone. (DE, Android)
+* Added new ARM SoCs (CPU, Linux / Android)
+
+Bugfixes:
+* Fixed I/O rate calculation precision in DiskIO and NetIO, and prevented division by zero. (DiskIO / NetIO)
+* Fixed the fast path of ash version detection. (Shell)
+* Fixed memory usage detection support on x86-32 FreeBSD (Memory, FreeBSD)
+    * Note: Although 32-bit systems are still supported, they are deprecated and barely tested. Users are encouraged to upgrade to 64-bit systems.
+* Some internal cleanups and optimizations.
+
+Logos:
+* Added macOS_old
+* Added Omarchy, Omarchy2
+
+# 2.67.1
+
+Bugfixes:
+* Fixed a `Symbol not found` error when running on macOS 10.15. (#2499, Codec, macOS)
+* Fixed Alacritty font size never being parsed from the TOML config. (#2501, TerminalFont)
+* Fixed bright colors incorrectly being active when the terminal uses a light theme. (#2509, Display)
+* Fixed Ghostty terminal font detection (TerminalFont)
+    * Now tries to load the config with the `.ghostty` extension. (#2500)
+    * Fixed `font-family` fallback order. (#2510)
+* Some internal cleanups and optimizations.
+
+Features:
+* Added a C23 compiler check so the build process gracefully exits during CMake configuration if the compiler is unsupported. (CMake)
+* Added compatibility workarounds for Apple Clang 16 to fix building on macOS 14. (CMake, macOS)
+* Reported real Android version codenames (e.g., "Baklava", "Vanilla Ice Cream") instead of "REL". (OS, Android)
+* Added Loadavg detection support on Haiku R1B6. (Loadavg, Haiku)
+* Enabled image logo support in the Zellij terminal multiplexer. (#2507, Logo)
+* Improved Locale detection on Windows (Locale, Windows)
+    * Now respects `LC_ALL` and `LANG` environment variables if set for better compatibility with MSYS2/cygwin.
+    * Appends the active system Code Page (e.g., `.UTF-8` or `.Windows-1252`) to the default system locale fallback.
+
+# 2.67.0
+
+Changes:
+* The minimum supported compiler version has been raised to GCC 13 (released on 2023-04-26) and Clang 16 (released on 2023-03-17) to accommodate the new C23 syntax used throughout the codebase. (General)
+    * As a result, building from source in Debian 12 (which only ships GCC 12 by default) is no longer supported. Users must upgrade their compiler or use the prebuilt binaries from the GitHub releases page.
+* The `general.preRun` option has been removed due to security concerns. (General)
+    * Users who relied on this option to run a command before printing output will need to move that logic to an external wrapper.
+* The `{status}` placeholder in Battery custom format is now an array type instead of a single comma-separated string. (Battery)
+    * This is a breaking change for users who print `{status}` in Lua scripts. They can use `table.concat(...)` to join the array into a single string if needed.
+* The `--gen-config-*` flags (`--gen-config-full`, `--gen-config-force`, `--gen-config-full-force`) have been removed and their functions have been merged into `--gen-config`. (Global)
+    * See features below.
+
+Features:
+* `--gen-config` now opens an interactive configuration TUI to make generating config files easier.
+    * It falls back to non-interactive generation when `$NO_COLOR` is set or when stdin/stdout is not a TTY. This behavior can also be used to disable the interactive mode.
+* Added an experimental [WebUI](https://fastfetch-cli.github.io/fastfetch-config/) ([separate project](https://github.com/fastfetch-cli/fastfetch-config)) for generating and editing configs.
+* Added `-w`/`--watch` as a seconds-based alias for `--dynamic-interval`, defaulting to 1 second when no value is provided. (#2478, Watch)
+* Added InitSystem detection on Windows, reporting the first userland process (`smss.exe`). (InitSystem, Windows)
+* Added CPU and GPU temperature detection support for Apple M5 series chips. (CPU / GPU, macOS)
+* Reported `Basic` as the Windows theme when DWM is disabled. (Theme, Windows)
+* Improved Ghostty terminal font detection performance. (#2122, TerminalFont)
+    * It now parses Ghostty directly instead of running `ghostty +show-config`.
+* Added support for a wider range of TOML config syntaxes used by Alacritty. (#2456, TerminalFont)
+
+Bugfixes:
+* Fixed a potential fish version detection error. (Shell, Linux)
+* Fixed incorrect resolution reporting when a monitor advertises multiple preferred modes. (#2481, Display, Linux)
+* Fixed connected monitors being missed when Wayland output events arrive late. (#2451, Display, Linux)
+* Fixed VP9 codec detection on macOS. (Codec, macOS)
+* Corrected Base64 encoding on big-endian hosts. (#2470)
+* Fixed invalid URL parsing in the PublicIP module. (PublicIP)
+* Correctly reported virtual GPUs on Windows. (#2461, GPU, Windows)
+* Added a size limit for network responses to prevent excessive memory usage and mitigate potential attacks. (PublicIP / Weather)
+* Fixed Ubuntu Studio Core detection. (OS, Linux)
+* Relaxed the HTTP response check so that both `HTTP/1.0` and `HTTP/1.1` responses are accepted when fetching data over the network. (PublicIP / Weather)
+* Various internal cleanups and optimizations:
+    * Fixed multiple memory leaks (Separator, Camera, Codec, Display).
+    * Added integer overflow checks to the string buffer implementation.
+    * Various code cleanups and compiler warning fixes.
+
+Logos:
+* Removed Hypros, MagpieOS, Furreto, EmperorOS and Magix
+
+# 2.66.0
+
+Changes:
+* CPU package count is no longer reported in the default output.
+    * Users can still print it in custom formats via `{packages}`
+
+Bugfixes:
+* Fixed compatibility with WSL 2.9.3 (#2433, WM, Linux)
+* Fixed AMD GPU names not being queried accurately in `driverSpecific` mode (GPU, Linux)
+* Fixed GPU core counting for Apple Silicon GPU on Asahi Linux (GPU, Linux)
+* Some internal cleanups and optimizations.
+
+Features:
+* Added Astra Linux version detection (OS, Linux)
+* Improved performance of Windows PowerShell version detection (Shell, Windows)
+* Improved performance of Media module on macOS (Media, macOS)
+* Added proxmox backup server detection (#2443, OS, Linux)
+
+Logos:
+* Added Flatcar, Azure Linux
+* Added Chimera_small, Chimera2, Parabola2_small, PostmarketOS2, Qubes_small
+* Updated linuxmint_small
+* Cleaned up distro names
+
+# 2.65.2
+
+Changes:
+* Memory usage calculations now exclude the ZFS ARC cache on Linux, FreeBSD, NetBSD, and SunOS. (#1995 / #2418, Memory)
+    * This prevents the Memory module from reporting artificially high memory usage on systems with the ZFS kmod enabled.
+
+Bugfixes:
+* The GPU module no longer pings sleeping dedicated GPUs on dual-GPU laptops. (#2419, GPU)
+    * As a result, PCIe link speed detection (introduced in v2.65.0) is now only enabled in `driverSpecific` mode.
+* Fixed a crash when detecting hardware codec support with the `amdgpu` driver on Linux. (#2419, Codec, Linux)
+
+Logos:
+* Updated CachyOS_small; fixed CachyOS logo colors to match the official logo better
+* Added Turkish
+
+# 2.65.1
+
+No changes
+
+# 2.65.0
+
+Changes:
+* `display.disableLinewrap` now defaults to `false`.
+    * This allows long lines to wrap instead of being truncated, preventing confusion for new users.
+    * Wrapped lines may overlap with the image logo. Users who prefer the old behavior can set `display.disableLinewrap: true` in their config file or use `--disable-linewrap true` on the command line.
+* Reorders package manager variables in custom format strings, moving aggregate variables (e.g., `all`, `brew-all`, `flatpak-all`) to the end. (Packages)
+    * This is a breaking change for users relying on numeric placeholders (e.g., `{1}`). Numeric placeholders are a long-deprecated feature; named placeholders (e.g., `{pacman}`) are always preferred and future-proof.
+* Enables `showPeCoreCount` by default to better display hybrid-architecture core counts. (CPU)
+* No longer accepts `chafa` options in config files if `chafa` support was disabled at compile time. (Logo)
+    * This may affect users who generated their config files using `fastfetch --gen-full-config`. To resolve this, simply remove the `chafa` section from the config file.
+
+Features:
+* Adds detection for CPU code names (e.g., "Alder Lake", "Zen 4") and manufacturing technologies (e.g., "Intel 7", "TSMC N4") on x86 processors. (#1501, CPU, X86)
+    * These can be used in custom formats via `{code-name}` and `{technology}`.
+* Adds PCIe link speed detection (current and max generation & lanes) for GPUs on Linux and Windows.
+    * These can be used in custom formats via `{pcie-max-speed}` and `{pcie-curr-speed}`.
+* Adds HDR display detection via the `wp-color-management-v1` Wayland protocol. (#2356, Display, Linux)
+    * Previously, HDR detection was only supported on KDE Plasma.
+* Adds the `egl-ext` detection method, which uses `EGL_EXT_device_enumeration` for GPU enumeration. (GPU)
+* Adds terminal version and font detection for `kmscon`. (#2393, Terminal / TerminalFont, Linux)
+* Adds the currently-in-beta code name "Golden Gate" for macOS 27. (OS, macOS)
+* Adds WPA version detection on FreeBSD. (Wifi, FreeBSD)
+* Adds package manager support for `porg` (#2405) and `install-release` (#2342). (Packages, Linux)
+* Adds Weston version detection. (WM, Linux)
+* Improves the core type (P-Core/E-Core) fetching mechanism on Windows by using `EfficiencyClass` instead of legacy frequency inference. (CPU, Windows)
+* Improves display detection compatibility with KDE 6.7. (Display, Linux)
+* Improves display serial number detection, now preferring alphanumeric serial numbers when available. (Display)
+    * This can be used in custom formats via `{serial}`.
+* Improves the performance of `emerge` package manager detection. (#2406, Packages, Linux)
+* Improves error messages for config file parsing errors.
+* Improves reliability of the `Codec` module on Linux (Codec, Linux)
+    * Adds `va-x11` backend for VA-API and VDPAU, which is used if `va-drm` backend fails to initialize.
+    * Fixes an issue where the Codec module incorrectly reports no results when the `codec.showType` option is set.
+
+Bugfixes:
+* Fixes physical core detection on non-x86 architectures and simplifies the frequency detection code. (CPU, Linux)
+* Fixes console mode and output code page initialization issues when running `fastfetch` in `Conhost`. (#2383, Windows)
+* Fixes public IP detection randomly failing on Linux. (#2401, PublicIP, Linux)
+* Fixes several memory leaks.
+
+Logos:
+* Adds Zerene OS. (#2404)
+
+# 2.64.2
+
+Bugfixes:
+* Fixes image rendering being wiped quickly (#2374)
+    * Regression from v2.64.0
+* Fixes ASCII logo being overwritten in `--dynamic-interval` mode
+    * Regression from v2.64.0
+
+Logos:
+* Updates OpenWrt and adds a small variant (#2376)
+    * The old one is renamed to `openwrt_old`
+
+# 2.64.1
+
+Features:
+* Adds a CMake option `-DPACKAGES_REMOVE_DISABLED` to remove detection code of disabled packages (`-DPACKAGES_DISABLE_<PACKAGE_NAME>`) for slightly smaller binary size (Packages)
+
+Bugfixes:
+* Fixes compatibility issues with Lua 5.3
+* Avoid possible infinite recursion in `encode_json` when encoding deeply nested tables or circular references
+* Fixes compilation issues when building with old macOS SDKs
+
+# 2.64.0
+
+New **optional build** dependencies:
+* [`libva`](https://github.com/intel/libva) and [`libvdpau`](https://www.freedesktop.org/wiki/Software/VDPAU) for the new `Codec` module.
+* [Lua 5.3 to 5.5](https://www.lua.org/) for Lua scripting support, or [QuickJS](https://github.com/quickjs-ng/quickjs) v0.15.0 or newer for JavaScript scripting support.
+
+Features:
+* Adds `Codec` module support for Windows, macOS, Linux, and Android for hardware-accelerated video codec detection (Codec)
+    * Backends used (results may vary depending on the backend due to driver differences):
+        * Linux and BSD: VA-API (default) and VDPAU (fallback for NVIDIA). Fastfetch must be built with `libva` and `libvdpau` support to enable these backends.
+        * Windows: D3D12VA (Windows 11) and D3D11VA+MFT (Windows 10 or older)
+        * macOS: VideoToolbox
+        * Android: AMediaCodec
+        * Common: Vulkan Video (disabled by default; can be enabled with `"useVulkan": true`)
+    * By default, both encoders and decoders are reported. If no codecs are detected for a given type, `None` is reported. This behavior can be configured using the `"showType": "encoder|decoder"` option.
+* Adds experimental Lua script support for custom formats (Global)
+    * Basic usage (using `Title` as an example): `{ "type": "title", "format": "lua:return string.format('Hello %s@%s', (...).userName, (...).hostName)" }`. The `lua:` prefix indicates a Lua script. A `return` statement is required to pass the final result back to the fastfetch module; otherwise, `nil` is returned implicitly and the entire module output is skipped.
+    * Parameters are passed via variable arguments `(...)`. Users can assign them to named variables for better readability. For example: `lua:local args = ...; string.format('Hello %s@%s', args.userName, args.hostName)`.
+    * The Lua interpreter instance is shared across all modules. This allows users to store and manipulate data across modules. For example:
+        * `{ "type": "shell", "format": "lua:shell = ..." } // Note: no "return" here`
+        * `{ "type": "terminal", "format": "lua:return shell.prettyName .. ' in ' .. (...).prettyName" } // This will print the detected shell and terminal names`
+    * A `json_encode(table, is_pretty)` function has been added to the Lua API for easier debugging. For example, `lua:return json_encode(...)` will print all available variables and their values in JSON format.
+    * Supported Lua versions: Lua 5.3 to 5.5 (Lua 5.1 and LuaJIT are not supported). The Lua version is auto-detected at build time. Once built, users can check the configured Lua version using `fastfetch --list-features`.
+* Adds experimental QuickJS script support for custom formats as an alternative to Lua (Global)
+    * Basic usage: `{ "type": "title", "format": "qjs:`Hello ${this.userName}@${this.hostName}`" }`. The `qjs:` prefix indicates a JavaScript script. No `return` statement is needed; the final result is simply the evaluated value of the script.
+    * Parameters are passed via the `this` object. Usage is mostly the same as Lua, but using JavaScript syntax.
+    * Requires [quickjs-ng v0.15.0](https://github.com/quickjs-ng/quickjs/releases/tag/v0.15.0) or newer.
+* Adds CMake options `-DMODULE_DISABLE_<MODULE_NAME>=ON` to disable modules at compile time for a smaller binary size
+    * Use `cmake -L . | grep MODULE_DISABLE_` to list all available options.
+    * These options rely on LTO for dead code elimination (`-DCMAKE_BUILD_TYPE=Release` should enable LTO by default).
+* Adds the ability to remove unneeded ASCII logos without modifying the fastfetch source code, further reducing binary size
+    * Simply remove the corresponding logo file from the logo directory (`src/logo/ascii/[a-z]/*`) and re-run `cmake`.
+* Improves string manipulation specifiers in custom formats
+    * They are now ANSI escape-aware and work correctly with colored output (e.g., percentages with `num-color`) (#2364). Limitations:
+        * They are still not wide-character aware and treat CJK and emoji characters as raw bytes.
+        * Escape sequences in the middle of strings are not supported.
+    * A new `|` specifier has been added to center strings. For example, `{user-name|20}` will center the username in a 20-character-wide field.
+* Adds preliminary `Bootmgr`, `Brightness`, and `WMTheme` detection support for Haiku (#2358, Haiku)
+* Adds `Wallpaper` and `WMTheme` detection support for the COSMIC desktop environment (Linux)
+* Improves terminal name detection for Nix packages (#2352, Terminal, Linux)
+* Adds DDC/CI brightness detection support for FreeBSD (Brightness, FreeBSD)
+    * DDC/CI communication can be very slow. Users can set the `ddcciSleep: null` option to skip DDC/CI detection.
+* Reworks the built-in logo printing logic. ASCII logos and modules are now printed line by line, avoiding issues like #2239
+    * Note: Image logos are not affected by this change and still print the entire image first before printing any modules.
+* Adds a new `--logo-padding-bottom` option to control the padding between the bottom of the logo and the first module when `--logo-position top` is used
+    * Previously, `--logo-padding-right` was used for both right and bottom padding.
+* Adds `Samsung Exynos 2600` to CPU detection (CPU, Android)
+* Adds terminal font detection support for the Muxy terminal (TerminalFont, macOS)
+* Improves the performance of BusyBox (ash) version detection and always reports `ash` as the pretty name (Shell, Linux)
+
+Bugfixes:
+* Fixes SwayFX version detection (WM, Linux)
+* Fixes fallback font detection for Ghostty (TerminalFont, macOS)
+* Fixes `--stat` output to correctly align with the right border (Global)
+* Fixes boot manager on macOS 26 (mBoot) is incorrectly reported as `iBoot` (Bootmgr, macOS)
+
+Logos:
+* Adds Quasar (#2338, #2323), Origami, Origami_small (#2321, #2322), BerserkArch (#2324, #2310), and NixOS2 (#2346)
+* Minor tweaks and color fixes for the NixOS_small logo (#2357)
+* Updates NurOS (#2366)
+
+# 2.63.1
+
+Bugfixes:
+* Fixes media length detection for Chrome on Linux (Media, Linux)
+* Fixes segmentation fault when specifying unsupported modules on command line
+* Disables usage of Netlink for Wi-Fi detection on s390x architectures (Wifi, Linux)
+
+# 2.63.0
+
+Changes:
+* Introduces a new **build-only** dependency, `libefl`, for querying the Enlightenment window manager configuration:
+    * `libefl-all-dev` on Debian/Ubuntu
+    * `libefl-devel` on Fedora
+    * `efl` on Arch Linux
+* The Windows-specific options `battery.useSetupApi` and `global.wmiTimeout` have been removed. (Windows)
+
+Features:
+* Adds wallpaper detection support on Haiku (#2314, Wallpaper, Haiku)
+* Adds Wi-Fi 6 GHz channel detection and improves protocol reporting (Wifi, Linux)
+* Improves Deepin version detection using `/etc/os-version` (#2300, OS, Linux)
+* Adds Ubuntu Kylin and Ubuntu Unity flavor detection (OS, Linux)
+* Adds NebiDE support (WMTheme, Linux)
+* Adds package counting for `cards` on NuTyX (#2287, Packages, Linux)
+* Adds `{am-pm}` to custom format for 12-hour time with am/pm (DateTime)
+* Adds support for the Enlightenment desktop environment (#2165, WM, Linux)
+* Adds support for playback progress detection (Media)
+    * The module now prints the current playback position and total media duration when supported by the player. If you prefer the previous behavior, you can set `media.percent.type: ["hide-others"]` to hide the new fields.
+* Adds support for `global.playerName` for Windows (Media, Windows)
+    * This allows detecting a specified media player while ignoring others.
+* Multi-battery detection is enabled on Windows by default (Battery, Windows)
+
+Bugfixes:
+* Improves DisplayServer compatibility on Linux by handling newer `kde-output-device-v2` protocol updates (DisplayServer, Linux)
+    * This fixes a long-standing issue where display detection fails with an `interface 'kde_output_device_mode_v2' has no event X` error.
+* Improves Wi-Fi reliability on Linux by switching to a netlink implementation (Wifi, Linux)
+* Improves network interface reliability and default route selection on macOS and Windows (Netif, macOS / Windows)
+* Validates temperature color thresholds as integers when parsing JSON configs (Temps)
+* Fixes TDE Konsole version detection (#2319, Terminal, Linux)
+* Various internal cleanups and optimizations
+
+Logos:
+* Adds KibaOS, NebiOS, XJ380, openRuyi, Ximper
+* Fixes GNOME OS built-in logo detection (#2296)
+
+# 2.62.1
+
+Bugfixes:
+* Fixes the Host module not working on some devices (#2279, Host, Linux)
+    * Regression from v2.61.0
+
+Logos:
+* Adds EN-OS, LimeOS, Redrose and Uzbek
+
+# 2.62.0
+
+Changes:
+* Sort package managers alphabetically in output and format arguments (Packages)
+    * The positional order of format arguments has changed — this is a breaking change for users relying on numeric placeholders. Named arguments are always preferred; e.g., use `{pacman}` (refer to `fastfetch -h packages-format`) instead of `{1}` to keep your config future-proof.
+
+Features:
+* Reports `Unused` instead of `Disabled` for zero-size swap on macOS (#2248, Swap, macOS)
+* Improves the robustness of default route detection on Linux (#2252, LocalIP, Linux)
+* PhysicalDisk module improvements
+    * Detects virtual disks and adds support for hiding them via `hideVirtual` option (defaults to `false`)
+    * Detects unused/disconnected disks and adds support for hiding them via `hideUnused` option (defaults to `true`)
+    * Adds support for OpenBSD and NetBSD (root privileges are required to access disk information)
+    * Improves interconnect type detection on SunOS
+    * Adds floppy drive support on Windows
+* Rewrites Windows GPU detection with D3DKMT APIs, unifying it with WSL GPU detection (GPU, Windows)
+* Verifies that the battery and power adapter are present before detection (Battery / PowerAdapter, Linux)
+* Improves PhysicalMemory reliability on OpenBSD and FreeBSD, including support for x86 UEFI systems on OpenBSD and non-UEFI systems on FreeBSD (PhysicalMemory, OpenBSD / FreeBSD)
+* Adds `display.common.(ndigits|spaceBeforeUnit)` options to configure common formatting for duration, percent, size, frequency and temperature values (#2234)
+* Slightly improves performance by skipping probes for ignored device types (Sound)
+* Adds support for AppImage package detection (#2179, Packages, Linux)
+
+Bugfixes:
+* Fixes a potential crash on certain Intel GPU models when using `--gpu-driver-specific` (#2259, GPU, Linux)
+* Doesn't report partitions as physical disks (DiskIO, NetBSD)
+* Fixes a typo (#2260, Wifi, macOS)
+* Corrects documentation for zpool format placeholders (#2261, Zpool)
+* Restores Windows 8.1 support (Cursor, Windows)
+* Fixes an out-of-bounds memory access when swaps are disabled (Swap, Windows)
+* Fixes battery status being incorrectly reported as `Charging` on systems with multiple batteries (#2263, Battery, Linux)
+* Fixes ash shell version detection (#2271, Shell, Linux)
+* Uses the `iterm` image protocol automatically on iTerm terminals for auto logo type (Logo)
+* Adds missing options when generating full config file
+
+Logos:
+* Updates AerynOS (#2272)
+
+# 2.61.0
+
+Changes:
+* Support for Windows 7 and 8 has been removed.
+    * Windows 8.1 is now the oldest version supported by fastfetch.
+* The GPU module on WSL no longer relies on `DXCore`.
+    * The `directx-headers` dependency is no longer required.
+    * Fastfetch on Linux is now pure C; a C++ compiler is no longer required.
+    * GPU type detection is now slightly less accurate, but detection speed should be slightly faster.
+* The GPU module on Windows now uses `DXCore` for more accurate GPU type detection (requires Windows 10 or later).
+    * This feature is built only when `DXCore` headers are available, which requires installing `mingw-w64-<msystem>-x86_64-directx-headers` on MSYS2.
+
+Features:
+* Adds a `brightness` option for color display configuration (#2238, Colors)
+* Adds support for detecting Bluetooth keyboards on Linux (#2220, Keyboard)
+* Adds support for detecting GlazeWM (WM, macOS)
+* Adds a `showEmptySlots` option to display empty memory slots on Linux (#2222, PhysicalMemory)
+* Adds marketing product name detection on Asahi Linux (Host, Linux)
+* Adds support for new M5 Mac models (Host, macOS)
+* Improves SMBIOS robustness by validating malformed data and improving error handling
+* Improves reliability when terminating child processes (Processing, Windows)
+* Improves Intel Mac support by querying SMBIOS data directly (Global, macOS)
+* Includes numerous internal cleanups and optimizations
+
+Bugfixes:
+* Fixes missing memory devices on some machines (PhysicalMemory)
+* Fixes CPUCache deduplication for shared caches (#2228, CPUCache, Linux)
+* Fixes WM version reporting for niri (#2218, WM, Linux)
+* Fixes SSID decoding issues from `iw` output (Wifi, Linux)
+* Fixes the CMD code page being changed after running fastfetch on Windows (#2245, Windows)
+
 # 2.60.0
 
 Changes:
@@ -450,7 +841,7 @@ Features:
 * Added support for interface speed detection on SunOS (LocalIP, SunOS)
 * Added detection support for Xlibre (#1888, WM, Linux)
 * Improved the accuracy of color detection (Cursor, macOS)
-* Improved the proformance of `Nix` package manager detection on macOS by porting optimizations form Linux port (#1893, Packages, macOS)
+* Improved the performance of `Nix` package manager detection on macOS by porting optimizations from the Linux port (#1893, Packages, macOS)
 
 Bugfixes:
 * Fixed custom object inheriting a key from the previous custom object if the key is blank (#1477)
@@ -961,7 +1352,7 @@ Features:
 * Change package manager name of NetBSD from `pkg` to `pkgsrc` (#1515, Packages, NetBSD)
 * Detect SOC name on RISCV (#1519, CPU, Linux)
 * Report marketing name of new QS8Es (CPU, Android)
-* Acquire acquire more os info from lsb-release if missing from os-release (#1521)
+* Acquire more OS info from lsb-release if missing from os-release (#1521)
 * CMake: add option `-DCUSTOM_LSB_RELEASE_PATH` to specify the path of `lsb-release` file
     * `-DCUSTOM_OS_RELEASE_PATH` has been supported since `v2.11.4`
 * Report more SOC names on Android (CPU, Android)
@@ -1429,7 +1820,7 @@ Logos:
 
 Bugfixes:
 * Fix bad Intel Arc GPU name detection, which was supposed to be fixed in the last version but the change was reverted accidentally (#1177, GPU, Linux)
-* Fix arm32 CPU name detection no longer work. Regression of 2.21.2 (CPU, Linux)
+* Fix arm32 CPU name detection no longer working. Regression of 2.21.2 (CPU, Linux)
 
 # 2.21.2
 
@@ -2924,7 +3315,7 @@ Features:
 * Enhance `--percent-type` to allow hiding other texts (#387)
 * Add Wifi module support for Linux
 * Detect scaled resolutions (Windows, macOS)
-* Optimise font module printing (Windows)
+* Optimize font module printing (Windows)
 * Detect pacman package count inside MSYS2 environment (Windows)
 * Add Wifi / Battery module support for Android
 * Disk name support for Linux

CONTRIBUTING.md

@@ -0,0 +1,724 @@
+# Contributing to fastfetch
+
+<details>
+    <summary>
+    Note
+    </summary>
+
+    This document is generated by AI, and mainly for AI use. It is not a substitute for human review, and may contain errors or omissions. Please verify any information before relying on it.
+</details>
+
+Thanks for your interest in fastfetch. This document covers building, architecture, how to add a module or a logo, code style, commit conventions, and the pull request workflow.
+
+fastfetch is a system information tool written in C23, supporting Linux, macOS, Windows, the BSDs, Solaris, Haiku and Android. The project is borderline obsessive about **startup time** and **optional dependencies** — many design decisions only make sense under that constraint, and this document keeps coming back to it.
+
+---
+
+## Table of contents
+
+- [Contributor quick reference](#contributor-quick-reference)
+- [Getting started](#getting-started)
+- [Code map](#code-map)
+- [Core architecture: modules vs. detection](#core-architecture-modules-vs-detection)
+- [Module registration](#module-registration)
+- [Walkthrough: adding a module](#walkthrough-adding-a-module)
+- [Walkthrough: adding a logo](#walkthrough-adding-a-logo)
+- [Platform conventions](#platform-conventions)
+- [Code style](#code-style)
+- [Commit messages](#commit-messages)
+- [Changelog](#changelog)
+- [Tests](#tests)
+- [Pull requests](#pull-requests)
+- [Gotchas](#gotchas)
+
+---
+
+## Contributor quick reference
+
+| Task | Start here | Verify with |
+|---|---|---|
+| Build and run fastfetch | `run.sh`, `CMakeLists.txt` | `./run.sh` |
+| Add a module | `src/modules/<name>/`, `src/detection/<name>/`, `src/modules/modules.c` | `cmake -B build && cmake --build build -j` |
+| Add a platform implementation | `src/detection/<name>/<name>_<platform>.c` | Build on the target platform or CI |
+| Add an ASCII logo | `src/logo/ascii/<letter>/<name>.txt`, matching `<letter>.inc` | `./build/fastfetch --logo <name>` |
+| Change formatting or JSON output | `src/modules/<name>/<name>.c` | `./build/fastfetch -s <name> --format json` |
+| Change shared formatting or containers | `src/common/format.h`, `src/common/color.h`, `src/common/FFstrbuf.h` | Build and run the matching test |
+| Run the test suite | `tests/`, `build/` | `cd build && ctest --output-on-failure` |
+
+For a normal code change, the shortest useful loop is: configure, build the `fastfetch` target, run the affected module, then run the tests. If you add a directory or a generated input, re-run `cmake -B build` so CMake refreshes its file globs.
+
+---
+
+## Getting started
+
+### Building
+
+The quickest way is `run.sh` in the repository root — it creates `build/`, configures, compiles and runs the binary:
+
+```sh
+./run.sh                 # build and run
+./run.sh --format json   # arguments are forwarded to fastfetch
+```
+
+Manual build:
+
+```sh
+cmake -B build -DCMAKE_BUILD_TYPE=RelWithDebInfo
+cmake --build build --target fastfetch -j$(nproc)
+./build/fastfetch
+```
+
+The default build type is `RelWithDebInfo`. LTO is enabled whenever `ENABLE_LTO=ON` **and** `CMAKE_BUILD_TYPE != Debug` — so the default already has it, and only `Debug` builds lack it. This matters because LTO here is not merely an optimization: it is what strips the code of disabled modules. See [Gotchas](#gotchas).
+
+### Common build options
+
+| Option | Default | Notes |
+|---|---|---|
+| `CMAKE_BUILD_TYPE` | `RelWithDebInfo` | LTO is on for anything but `Debug` |
+| `BUILD_TESTS` | `OFF` | Builds the unit tests in `tests/` |
+| `BUILD_FLASHFETCH` | `ON` | Also builds the stripped-down `flashfetch` |
+| `BINARY_LINK_TYPE` | `dlopen` | `dlopen` / `dynamic` / `static` |
+| `ENABLE_ASAN` | `OFF` | Address Sanitizer |
+| `ENABLE_LTO` | `ON` | Link-time optimization |
+| `MODULE_DISABLE_<NAME>` | `OFF` | Disable a module, e.g. `MODULE_DISABLE_GPU=ON` |
+| `SET_TWEAK` | `ON` | Appends a tweak to the dev version; turned off for releases |
+
+`BINARY_LINK_TYPE=dlopen` (the default) is a deliberate design choice: optional dependencies (Vulkan, Wayland, DBus, ImageMagick, chafa, …) are loaded at runtime, so a missing library never prevents startup. When adding a third-party dependency, use the dlopen helpers in `common/library.h` — do not link it directly.
+
+For a minimal-dependency build, see `.github/workflows/build-no-features-test.yml`:
+
+```sh
+cmake -DBUILD_TESTS=On -DENABLE_VULKAN=OFF -DENABLE_WAYLAND=OFF -DENABLE_X11=OFF \
+      -DENABLE_DBUS=OFF -DENABLE_ZLIB=OFF ... .
+```
+
+### Dependencies
+
+Required: CMake ≥ 3.21 and a C23 compiler (GCC, Clang or MSVC). Everything else is optional.
+
+Optional dependencies are auto-detected: libpci, libdrm, vulkan, wayland, xcb, xrandr, dbus, sqlite3, rpm, imagemagick{6,7}, chafa, zlib, egl, glx, opencl, freetype, pulse, ddcutil, elf, libzfs, and more.
+
+---
+
+## Code map
+
+```
+src/
+├── fastfetch.c          entry point: CLI parsing, module dispatch, main loop (36 KB)
+├── flashfetch.c         entry point for the stripped-down build
+├── options/             global (non-module) config: general / display / logo
+├── modules/             module layer — module formatting and output
+├── detection/           detection layer — platform-specific data retrieval
+├── common/              infrastructure: FFstrbuf, FFlist, formatting, printing, networking
+├── logo/                530 ASCII logos plus the image logo backends
+└── 3rdparty/            yyjson, widecharwidth, display-library
+```
+
+Flow of control:
+
+```
+fastfetch.c  →  options/    (global configuration)
+             →  modules/    (76 modules, formatting and output)
+             →  detection/  (one platform implementation each, raw data)
+             →  common/     (infrastructure)
+```
+
+The number of module directories and detection directories does not match, and that is expected. The following relationships are structural rather than a fixed inventory:
+
+- **13 modules have no detection directory** — they are either pure layout (`break`, `separator`, `colors`, `title`, `logo`) or reuse someone else's detection result (`display`, `monitor`, `kernel`, `shell`, `terminal`, `player`, `custom`, `datetime`).
+- **4 detection directories serve modules with different names** — `displayserver` (→ `display`, `monitor`), `gtk_qt` (→ `theme`, `icons`, `font`, `cursor`), `terminalshell` (→ `terminal`, `shell`) and `libc`.
+
+So do not assume `modules/<x>/` always has a matching `detection/<x>/`.
+
+### Layer boundaries
+
+| Layer | Owns | Must not |
+|---|---|---|
+| `options/` | **Global** config (colors, logo, threading, timeouts) | hold per-module options |
+| `modules/` | formatting, printing, JSON serialization | read `/proc`, call Win32 APIs, parse sysfs |
+| `detection/` | cross-platform data retrieval, clean result structs | print anything, read display config |
+| `common/` | general-purpose utilities, no business logic | depend on a specific module |
+
+The test is simple: **no file under `detection/` should contain `printf` or read `instance.config`.** Symmetrically, no file under `modules/` should contain `#ifdef __linux__`.
+
+---
+
+## Core architecture: modules vs. detection
+
+This is the single most important convention in the codebase. Every feature is a fixed set of files — using CPU as the example:
+
+```
+modules/cpu/option.h           module option struct
+modules/cpu/cpu.c              formatting and output
+detection/cpu/cpu.h            platform-independent interface
+detection/cpu/cpu_linux.c     ┐
+detection/cpu/cpu_apple.c     │
+detection/cpu/cpu_windows.c   ├─ platform implementations, one linked per build
+detection/cpu/cpu_bsd.c       │
+detection/cpu/cpu_nosupport.c ┘
+```
+
+The interface is deliberately minimal — usually just two things:
+
+```c
+typedef struct FFCPUResult { ... } FFCPUResult;   // result struct
+const char* ffDetectCPU(const FFCPUOptions* options, FFCPUResult* cpu);
+```
+
+The `const char*` return value is an **error string**; `nullptr` means success. This pattern is used throughout `detection/` — please keep it consistent.
+
+Helper functions are only exposed when they are genuinely shared between platform implementations (as in `cpu.h`: `ffCPUAppleCodeToName`, `ffCPUDetectByCpuid`).
+
+**The payoff:** adding a platform never touches `modules/`; fixing output formatting never touches `detection/`.
+
+---
+
+## Module registration
+
+### The descriptor
+
+Every module exports one `FFModuleBaseInfo` (defined in `common/option.h:46`) — essentially a hand-written vtable:
+
+```c
+typedef struct FFModuleBaseInfo {
+    const char* name;                    // lookup key, e.g. "cpu"
+    const char* description;             // help text
+    FFModuleDisplayName displayName;     // module name in 20 languages
+
+    void (*initOptions)(void* options);
+    void (*destroyOptions)(void* options);
+    void (*parseJsonObject)(void* options, struct yyjson_val* module);
+    bool (*printModule)(void* options);
+    bool (*generateJsonResult)(void* options, yyjson_mut_doc*, yyjson_mut_val*);
+    void (*generateJsonConfig)(void* options, yyjson_mut_doc*, yyjson_mut_val*);
+
+    FFModuleFormatArgList formatArgs;    // format placeholder table
+    const uint8_t defaultOrder;          // sort weight
+} FFModuleBaseInfo;
+```
+
+The source comment openly admits this is UB — `void*` is not compatible with `FF*Options*`. It is a pragmatic compromise to get polymorphism in C. Don't try to "fix" it.
+
+### The registry: a first-letter hash bucket
+
+`src/modules/modules.c` defines 26 `static FFModuleBaseInfo*` arrays (`A[]` through `Z[]`), each terminated by `nullptr`, collected into `ffModuleInfos[26]`:
+
+```c
+FFModuleBaseInfo** modules = ffModuleInfos[toupper(name[0]) - 'A'];  // O(1) bucket lookup
+for (; *modules; ++modules) {                                        // linear scan in the bucket
+    if (ffStrEqualsIgnCase(name, (*modules)->name)) { ... }
+}
+```
+
+The registry is small enough that a subtraction plus a few string comparisons is preferable to a general-purpose hash table. When adding a module, place its descriptor in the bucket matching the first letter of `.name`; keep the existing `nullptr` terminator at the end.
+
+### The calling convention: zero heap allocation
+
+Every dispatch site (`jsonconfig.c:98`, `commandoption.c:189`) follows the same pattern:
+
+```c
+alignas(uint64_t) uint8_t optionBuf[FF_OPTION_MAX_SIZE];  // 256 bytes, on the stack
+baseInfo->initOptions(optionBuf);
+baseInfo->parseJsonObject(optionBuf, jsonVal);             // JSONC path only
+baseInfo->printModule(optionBuf);                          // or generateJsonResult
+baseInfo->destroyOptions(optionBuf);
+```
+
+`FF_OPTION_MAX_SIZE = 1 << 8` (256 bytes). Every module's `option.h` must end with:
+
+```c
+static_assert(sizeof(FFCPUOptions) <= FF_OPTION_MAX_SIZE, "FFCPUOptions size exceeds maximum allowed size");
+```
+
+**Meaning: no module option struct may exceed 256 bytes.** Hard constraint, enforced at compile time.
+
+The three dispatch entry points:
+
+| Entry point | Location | Used for |
+|---|---|---|
+| `parseModuleJsonObject` | `common/impl/jsonconfig.c:90` | the `modules[]` array in a JSONC config |
+| `parseStructureCommand` | `common/impl/commandoption.c:181` | the colon-separated structure string |
+| `ffParseModuleOptions` | `common/impl/commandoption.c:13` | **deprecated** — see [Gotchas](#4-cli-module-options-are-removed) |
+
+### Build-time module discovery
+
+`CMakeLists.txt:131` globs `src/modules/*/` and generates a `MODULE_DISABLE_<UPPER>` option per directory:
+
+```cmake
+file(GLOB FF_MODULE_DIRS RELATIVE "..." ".../src/modules/*/")
+foreach(FF_MODULE_DIR ${FF_MODULE_DIRS})
+    option(MODULE_DISABLE_${FF_MODULE_UPPER} "Disable module ${FF_MODULE_DIR}" OFF)
+endforeach()
+```
+
+**Adding a module requires no CMake change.** The same trick generates the package manager switches (`:146` regex-scans `src/modules/packages/option.h` for `FF_PACKAGES_FLAG_*_BIT`).
+
+---
+
+## Walkthrough: adding a module
+
+Adding a `Foo` module, step by step.
+
+### 1. Define the option struct
+
+`src/modules/foo/option.h`:
+
+```c
+#pragma once
+
+#include "common/option.h"
+
+typedef struct FFFooOptions {
+    FFModuleArgs moduleArgs;   // must be the first field
+    bool showBar;
+} FFFooOptions;
+
+static_assert(sizeof(FFFooOptions) <= FF_OPTION_MAX_SIZE, "FFFooOptions size exceeds maximum allowed size");
+```
+
+`FFModuleArgs` must come first. It provides `key`, `format`, `outputColor`, `keyColor`, `keyIcon` and `keyWidth`; because it is the first field, `ffJsonConfigParseModuleArgs()` can handle these generically and you get them **for free — no parsing code to write**.
+
+Note these fields can only be set through the JSON config; CLI module options have been removed (see [Gotchas](#4-cli-module-options-are-removed)).
+
+### 2. Implement detection
+
+`src/detection/foo/foo.h`:
+
+```c
+#pragma once
+#include "fastfetch.h"
+
+typedef struct FFFooResult {
+    FFstrbuf name;
+    uint32_t count;
+} FFFooResult;
+
+const char* ffDetectFoo(const FFFooOptions* options, FFFooResult* result);
+```
+
+`src/detection/foo/foo_linux.c`:
+
+```c
+#include "foo.h"
+
+const char* ffDetectFoo(const FFFooOptions* options, FFFooResult* result) {
+    // read /sys, /proc, sysfs, dbus, ...
+    return nullptr;  // success; return an error string on failure
+}
+```
+
+**Write one file per target platform, and a `foo_nosupport.c` fallback for the rest.** There are already 45 `*_nosupport.c` files doing exactly this.
+
+### 3. Implement the module
+
+`src/modules/foo/foo.c` — implement the six functions, then define the descriptor:
+
+```c
+FFModuleBaseInfo ffFooModuleInfo = {
+    .name = "Foo",
+    .description = "Print foo information",
+    .displayName = {
+        .en = "Foo", .ar = "Foo", .cs = "Foo", .de = "Foo", .es = "Foo",
+        .fr = "Foo", .gl = "Foo", .he = "Foo", .id = "Foo", .it = "Foo",
+        .ja = "Foo", .ko = "Foo", .pl = "Foo", .pt = "Foo", .ru = "Foo",
+        .tr = "Foo", .uk = "Foo", .vi = "Foo", .zh_CN = "Foo", .zh_TW = "Foo",
+    },
+    .initOptions = (void*) ffInitFooOptions,
+    .destroyOptions = (void*) ffDestroyFooOptions,
+    .parseJsonObject = (void*) ffParseFooJsonObject,
+    .printModule = (void*) ffPrintFoo,
+    .generateJsonResult = (void*) ffGenerateFooJsonResult,
+    .generateJsonConfig = (void*) ffGenerateFooJsonConfig,
+    .formatArgs = FF_FORMAT_ARG_LIST(((FFModuleFormatArg[]) {
+        { "Name", "name" },
+        { "Count", "count" },
+    })),
+    .defaultOrder = 73,
+};
+```
+
+Points to note:
+
+- **`displayName`** is a literal block of all 20 language fields — there is no shortcut macro, so copy the layout from a neighboring module: **`en`, `ar`, `cs`, `de`, `es`, `fr`, `gl`, `he`, `id`, `it`, `ja`, `ko`, `pl`, `pt`, `ru`, `tr`, `uk`, `vi`, `zh_CN`, `zh_TW`**.
+  **Fill in all 20.** The struct is read by byte offset (see [Gotchas](#6-localization-uses-byte-offsets-not-enums)) and there is **no fallback** — a missing field means the key prints empty in that language.
+- **`formatArgs`** must be exhaustive. It drives the placeholder list printed by `fastfetch -h foo-format`; **anything you omit is invisible and unusable to the user.**
+- The `moduleFormat` section in `doc/json_schema.json` is generated by `fastfetch -h format-json`. Its metadata comes from `FFModuleBaseInfo::formatArgs`. To keep the schema and module descriptors consistent, do not edit the `moduleFormat` section in `doc/json_schema.json` by hand; update the module metadata and regenerate it instead.
+- **`defaultOrder`**: use the current maximum plus 1. Search the existing descriptors for `.defaultOrder =` before choosing a value; do not copy a hard-coded value from this document. Leaving it out, or setting it to `0`, makes the module **disappear** from the interactive `--gen-config` picker. Only `logo`, `command` and `custom` do this deliberately, because they need user arguments or are invoked directly by the display layer.
+
+### 4. Register it
+
+- Add `#include "modules/foo/foo.h"` to `src/modules/modules.h`
+- Insert into the `F[]` array in `src/modules/modules.c`:
+
+```c
+#if !FF_MODULE_DISABLE_FOO
+    &ffFooModuleInfo,
+#endif
+```
+
+`FF_MODULE_DISABLE_FOO` is generated by CMake — you do not define it yourself.
+
+### 5. Modules that need warm-up
+
+If your module needs a sampling interval (CPU usage) or a network round-trip (public IP, weather), also implement `ffPrepareFoo()` and register it in the switch inside `ffPrepareCommandOption()` in `common/impl/commandoption.c`, under the right first-letter `case`. Six modules do this today: CPUUsage, DiskIO, NetIO, PublicIP, Top and Weather.
+
+### 6. Verify
+
+```sh
+cmake -B build && cmake --build build -j
+./build/fastfetch -s foo --format json    # JSON output
+./build/fastfetch -h foo-format           # list formatArgs placeholders
+./build/fastfetch --gen-config            # confirm it appears in the picker
+```
+
+Note the `-format` suffix on the help flag: `fastfetch -h foo` does not work, only `fastfetch -h foo-format`.
+
+---
+
+## Walkthrough: adding a logo
+
+A new logo **must** have a corresponding "Logo Request" issue, linked from the PR with `Closes #1234`. Logo PRs without a linked issue are not accepted.
+
+### 1. Drop in the ASCII file
+
+```
+src/logo/ascii/<first-letter>/<distro>.txt
+```
+
+For example `src/logo/ascii/o/omarchy.txt`. Directories are already split by first letter (`a/` … `z/`, plus `_/`).
+
+The file is plain ASCII art with `$1` … `$9` as color placeholders:
+
+```
+                 $3 ,-^-___
+$3                /\\\///
+$2refined.$1       /\\\\//
+```
+
+- `$1` … `$9` map to palette slots 1–9; at most 9 (`FASTFETCH_LOGO_MAX_COLORS = 9`)
+- `$$` is a literal `$`
+- Characters without a placeholder inherit the current color. Of the 530 existing logos, 239 use no placeholders at all (monochrome) and 291 do — **new logos should use placeholders**; monochrome is a legacy style
+- Tabs are expanded to 4 spaces
+- Colors can be overridden with `--logo-color-1` … `--logo-color-9`
+
+### 2. Register it in the `.inc`
+
+CMake turns each `.txt` into a `FASTFETCH_DATATEXT_LOGO_<UPPERCASE>` macro (`CMakeLists.txt:418`), but **the registry itself is maintained by hand**. Edit `src/logo/ascii/<first-letter>.inc`:
+
+```c
+#ifdef FASTFETCH_DATATEXT_LOGO_OMARCHY
+// Omarchy
+{
+    .names = { "omarchy", "Omarchy" },
+    .lines = FASTFETCH_DATATEXT_LOGO_OMARCHY,
+    .colors = {
+        FF_COLOR_FG_BLUE,
+        FF_COLOR_FG_WHITE,
+        FF_COLOR_FG_CYAN,
+    },
+},
+#endif
+```
+
+- `names` is matched case-insensitively. Do not add names that differ only by case, because they can never be distinguished. Every name is also shown by `--list-logos`, so use user-friendly spelling such as an initial capital where appropriate.
+- For a new logo, use exactly one name unless there is a specific compatibility reason to add more. That name should first be the `ID` from `/etc/os-release`. If the ID cannot distinguish this logo from another logo for the same OS, use the `NAME` value instead. `logoGetBuiltinDetected` in `src/logo/logo.c` documents the detection order: `ID`, then `NAME`, then tokens from `ID_LIKE`, then the platform name fallback. Manual `logo-source` selection uses the name directly.
+- `colors` is positional — entry 0 is `$1`, entry 1 is `$2`, and so on
+- `colors[0]` also becomes the title color and `colors[1]` the key color, unless the user overrides them
+
+If the same OS has multiple logo variants, mark the variant explicitly with `.type`:
+
+```c
+.type = FF_LOGO_LINE_TYPE_SMALL_BIT,
+```
+
+Use `FF_LOGO_LINE_TYPE_ALTER_BIT` for an alternate logo, `FF_LOGO_LINE_TYPE_SMALL_BIT` for a small logo, or combine the flags when both apply. This is also a lookup optimization: a logo marked `FF_LOGO_LINE_TYPE_SMALL_BIT` is considered only for `type = small`, while a logo marked `FF_LOGO_LINE_TYPE_ALTER_BIT` is never selected by automatic detection. Alternate logos are available only when explicitly requested through `--logo <source>`.
+
+### 3. Verify
+
+```sh
+./build/fastfetch --logo omarchy
+./build/fastfetch --list-logos | grep -i omarchy
+```
+
+---
+
+## Platform conventions
+
+The `detection/` layer picks its implementation by **filename suffix**; the choice is made at build time from `CMAKE_SYSTEM_NAME`:
+
+| Suffix | Platform |
+|---|---|
+| `_linux.c` | Linux |
+| `_apple.c` / `_apple.m` | macOS / iOS (`.m` for Objective-C) |
+| `_windows.c` / `_windows.cpp` | Windows (`.cpp` for WinRT / WMI) |
+| `_bsd.c` | FreeBSD |
+| `_nbsd.c` | NetBSD |
+| `_obsd.c` | OpenBSD |
+| `_sunos.c` | Solaris / illumos |
+| `_haiku.c` / `.cpp` | Haiku |
+| `_android.c` | Android (Termux) |
+| `_gnu.c` | GNU/Hurd |
+| `_nosupport.c` | Empty fallback |
+
+Current distribution of platform files in `detection/`:
+
+| Suffix | Files | Suffix | Files |
+|---|---|---|---|
+| `_linux` | 58 | `_obsd` | 16 |
+| `_windows` | 47 | `_haiku` | 13 |
+| `_apple` | 46 | `_android` | 12 |
+| `_nosupport` | 45 | `_gnu` | 3 |
+| `_bsd` | 29 | | |
+| `_sunos` | 19 | | |
+| `_nbsd` | 17 | | |
+
+(These are repository inventory figures, counting `.c`, `.m`, `.cpp`, and `.h`; they may change as platforms and modules are added.)
+
+**Don't pile `#ifdef __linux__` into one file.** When adding platform support, copy the closest existing implementation and change the suffix.
+
+`common/` uses the same idea: `common/impl/` contains `io_unix.c` / `io_windows.c`, `netif_linux.c` / `netif_apple.c` / `netif_bsd.c` and so on, with `common/apple/`, `common/windows/` and `common/haiku/` holding platform-specific helpers.
+
+When several platform suffixes could apply, use the most specific implementation supported by the build system (for example, `_nbsd.c` instead of the generic `_bsd.c` on NetBSD). Keep the generic file as the fallback for platforms that share its conventions.
+
+---
+
+## Code style
+
+### Formatting
+
+The project uses clang-format with `BasedOnStyle: LLVM` plus these key overrides:
+
+```yaml
+IndentWidth: 4
+UseTab: Never
+ColumnLimit: 0              # never wrap
+InsertBraces: true          # braces even on single-statement ifs
+PointerAlignment: Left      # char* p, not char *p
+SortIncludes: Never         # include order is managed by hand
+AlignAfterOpenBracket: DontAlign
+BinPackParameters: false    # all params on one line, or one per line
+```
+
+Before committing:
+
+```sh
+clang-format -i src/modules/foo/*.c src/modules/foo/*.h
+```
+
+`src/3rdparty/**`, `build/**` and `src/logo/builtin.c` are listed in `.clang-format-ignore` — **do not reformat them.**
+
+`.editorconfig` adds LF line endings, 4-space indent, a final newline, and trailing whitespace trimmed (except in Markdown).
+
+### Naming
+
+| Kind | Convention | Example |
+|---|---|---|
+| Functions | `ff` + PascalCase | `ffDetectCPU`, `ffPrintCPU` |
+| Types | `FF` + PascalCase | `FFCPUResult`, `FFModuleBaseInfo` |
+| Variables / fields | camelCase | `coresPhysical`, `keyWidth` |
+| Macros | SCREAMING_SNAKE_CASE | `FF_OPTION_MAX_SIZE` |
+| Module options | `FF<Name>Options` | `FFCPUOptions` |
+| Detection results | `FF<Name>Result` | `FFCPUResult` |
+
+### Spelling
+
+CI runs codespell (`.codespellrc`). Known false positives live in `ignore-words-list` (`iterm`, `compiletime`, and various non-English distro words). Add new words there rather than changing the code.
+
+### Compiler warnings
+
+The build enables `-Wall -Wextra -Wconversion` plus several `-Werror`s:
+
+```
+-Werror=uninitialized -Werror=return-type -Werror=vla
+-Werror=incompatible-pointer-types -Werror=implicit-function-declaration -Werror=int-conversion
+```
+
+**`-Wconversion` is strict**: every implicit narrowing conversion needs an explicit cast.
+
+---
+
+## Commit messages
+
+Format:
+
+```
+<Scope>[ (Platform)]: <third-person singular verb> <object>
+```
+
+Scope is the module or subsystem name; Platform is optional. Use the third-person singular present tense, capitalize the first letter, no trailing period.
+
+Real examples from recent history:
+
+```
+Processes (Haiku): honors `options->countKprocs`
+WM (macOS): improves reliability of WM plugin detection
+Memory (Windows): prefers `NQSI`
+Top (Linux): improves performance of `stat` parsing
+Logo (Builtin): adds omarchy
+Global: introduces global macro `FF_PATH_PKG_BASE` to replace `_PATH_LOCALBASE`
+LM (OpenBSD): adds support
+CI: disables fail on alert
+Doc: updates README
+Presets: moves `top` to the bottom of running modules [ci skip]
+```
+
+Common verbs: `adds`, `removes`, `fixes`, `improves`, `updates`, `corrects`, `prefers`, `honors`, `disables`, `enables`, `introduces`, `detects`, `reports`, `skips`, `uses`.
+
+Scopes in use: `Top`, `Processes`, `Memory`, `Logo (Builtin)`, `CI`, `Doc`, `Presets`, `Global`, plus individual module names.
+
+Documentation-only changes get a `[ci skip]` suffix.
+
+---
+
+## Changelog
+
+User-visible changes go into `CHANGELOG.md`, under the topmost version heading:
+
+```markdown
+# Unreleased
+
+Changes:
+* The DE / WM / LM modules now reports the full name ...
+
+Features:
+* Added Top module to print processes with the highest CPU, memory or disk I/O usage. (Top)
+* Improved Wi-Fi module
+    * Added Wifi channel width detection, exposed via `{channel-width}` in custom format.
+    * Improved Wifi channel frequency accuracy on Windows, macOS.
+* Added Battery detection support on SunOS. (Battery, SunOS)
+
+Bugfixes:
+* Fixed I/O rate calculation precision in DiskIO and NetIO. (DiskIO / NetIO)
+```
+
+Rules:
+
+- Three sections: `Changes:` (behavior changes), `Features:`, `Bugfixes:`
+- Past tense: `Added` / `Fixed` / `Improved`
+- End each entry with its scope: `(Module, Platform)` or `(ModuleA / ModuleB)`
+- Sub-bullets are indented 4 spaces
+
+---
+
+## Tests
+
+Tests are standalone executables in `tests/` using a `VERIFY` macro that exits non-zero on failure:
+
+```c
+#define VERIFY(expression) \
+    if (!(expression)) testFailed(&strbuf, #expression, __LINE__)
+```
+
+Current tests: `strbuf.c`, `list.c`, `format.c`, `color.c`, `duration.c`, `strutil.c`.
+
+```sh
+cmake -B build -DBUILD_TESTS=On
+cmake --build build
+cd build && ctest --output-on-failure
+```
+
+Coverage focuses on the core data structures and the formatting engine in `common/`. The `detection/` layer has no automated tests (it depends too heavily on a real system) and is instead covered by the CI matrix — 20 workflows under `.github/workflows/` spanning Linux (including musl, loong64, armv7l, i686), macOS, Windows, FreeBSD, NetBSD, OpenBSD, DragonFly, Solaris, OmniOS and Haiku, plus spellcheck and benchmark jobs.
+
+**If you touch `common/FFstrbuf.h`, `common/format.h` or `common/color.h`, please extend the matching test.**
+
+---
+
+## Pull requests
+
+1. **Open an issue first** (feature request / bug report / logo request) so you don't waste effort. Templates are in `.github/ISSUE_TEMPLATE/`.
+2. Branch off `dev` — **`dev` is the main development branch**, not `master`.
+3. Follow the [commit message convention](#commit-messages).
+4. Update `CHANGELOG.md` for user-visible changes.
+5. Open the PR against `dev` and fill in `.github/pull_request_template.md`:
+   - Summary
+   - Related issue (**required for new logos**, otherwise the PR won't be accepted)
+   - Changes
+   - Screenshots (required for visual changes)
+   - Checklist: confirm you tested locally
+
+### Pre-submit checklist
+
+```sh
+clang-format -i <changed files>                  # format
+codespell                                        # spelling
+cmake -B build -DBUILD_TESTS=On && cmake --build build -j
+cd build && ctest --output-on-failure            # tests
+./build/fastfetch --format json                  # verify JSON output is well-formed
+./build/fastfetch -c presets/all.jsonc --stat false   # smoke-test every module
+```
+
+---
+
+## Gotchas
+
+Things that are easy to get wrong when reading this codebase. Most of them follow from the "obsessively fast startup" goal.
+
+### 1. Option structs must not exceed 256 bytes
+
+`FF_OPTION_MAX_SIZE = 1 << 8`. Exceeding it is caught at compile time by `static_assert`. Don't try to raise the value — it determines the stack cost of every module invocation.
+
+### 2. `FF_MODULE_DISABLE_*` controls registration, not compilation
+
+```c
+// verbatim from the top of modules/modules.c:
+// FF_MODULE_DISABLE_<module> only controls if the module is registered,
+// the module code itself is still compiled.
+// We rely `LTO` to remove the unused code (only enabled in Release mode)
+```
+
+**Disabling modules in a Debug build does not shrink the binary.** LTO is enabled whenever `CMAKE_BUILD_TYPE != Debug`, and the default `RelWithDebInfo` already satisfies that — so measure size with `RelWithDebInfo` or `Release`, never with `Debug`. (The "Release mode" wording in the comment above is imprecise.)
+
+### 3. CMake globs don't trigger reconfiguration
+
+Both the module directories and the logo files are discovered by glob. CMake will not notice new files on its own — you need to re-run `cmake -B build` (or delete `build/CMakeCache.txt` and start over). This is the classic CMake footgun.
+
+### 4. CLI module options are removed
+
+Per-module command-line flags such as `--cpu-temp` are **no longer supported**. The only job of `ffParseModuleOptions` now is to translate the flag into a JSON key, then `exit(477)` with a pointer to the config file:
+
+```
+Error: Unsupported module option: --cpu-temp
+       Support of module options has been removed. Please add the flag to the JSON config instead.
+       Example (demonstration only): `{ "modules": [ { "type": "cpu", "temp": true } ] }`
+```
+
+**JSONC is the first-class configuration interface; the command line is not.** When adding module options, implement `parseJsonObject` only — do not add a CLI branch.
+
+### 5. `defaultOrder = 0` hides a module from `--gen-config`
+
+`collectModuleInfos` (`genconfig.c:186`) skips any module whose `defaultOrder` is `0`. C zero-initializes the field, so **omitting it is the same as setting it to 0**. Only `logo`, `command` and `custom` do this on purpose.
+
+`defaultOrder` affects only the ordering in the interactive `--gen-config` picker; it has no effect on runtime output order.
+
+### 6. Localization uses byte offsets, not enums
+
+`instance.config.display.keyLanguage` does not hold a language enum — it holds a **byte offset** such as `offsetof(FFModuleDisplayName, zh_CN)`. The macro `FF_MODULE_GET_DISPLAY_NAME` (`common/option.h:123`) does plain pointer arithmetic with it:
+
+```c
+#define FF_MODULE_GET_DISPLAY_NAME(moduleName) \
+    (*(const char**) ((uint8_t*) &ff ## moduleName ## ModuleInfo.displayName + instance.config.display.keyLanguage))
+```
+
+Consequence: **the field order of `FFModuleDisplayName` must never change** — reordering silently scrambles every language.
+
+### 7. The `multithreading` switch barely does anything
+
+The global `multithreading` option currently takes effect in exactly one place: `common/impl/networking_linux.c:339`. Modules are still printed sequentially. Modules that need concurrency go through the `ffPrepare*` warm-up hooks instead, which start sampling or fire off requests before the print loop begins.
+
+### 8. Don't print or read config inside `detection/`
+
+The `detection/` layer must stay pure: read system state, fill a struct, return an error string. Any `printf` or any read of `instance.config` there is a design error.
+
+### 9. `src/logo/builtin.c` and `3rdparty/` are formatting-exempt
+
+The former is a large generated/hand-maintained data table, the latter is upstream code. Both are excluded via `.clang-format-ignore` — leave them alone.
+
+---
+
+## Reference
+
+- Configuration guide: <https://github.com/fastfetch-cli/fastfetch/wiki/Configuration>
+- JSON schema: `doc/json_schema.json`
+- Example presets: `presets/` (`all.jsonc`, `neofetch.jsonc`, `ci.jsonc`, …)
+- Man page source: `doc/fastfetch.1.in`
+- Code generation scripts: `scripts/` (`gen-pciids.py`, `gen-amdgpuids.py`, `gen-man.py`)

README.md

@@ -1,5 +1,6 @@
 # Fastfetch
 
+[![Benchmark](https://img.shields.io/badge/GitHub%20Pages-live-blue?logo=github)](https://fastfetch-cli.github.io/fastfetch/dev/bench)
 [![GitHub Workflow Status (with event)](https://img.shields.io/github/actions/workflow/status/fastfetch-cli/fastfetch/ci.yml)](https://github.com/fastfetch-cli/fastfetch/actions)
 [![GitHub license](https://img.shields.io/github/license/fastfetch-cli/fastfetch)](https://github.com/fastfetch-cli/fastfetch/blob/dev/LICENSE)
 [![GitHub contributors](https://img.shields.io/github/contributors/fastfetch-cli/fastfetch)](https://github.com/fastfetch-cli/fastfetch/graphs/contributors)
@@ -13,7 +14,9 @@
 [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/fastfetch-cli/fastfetch)
 [![中文README](https://img.shields.io/badge/%E4%B8%AD%E6%96%87-README-red)](README-cn.md)
 
-Fastfetch is a [neofetch](https://github.com/dylanaraps/neofetch)-like tool for fetching system information and displaying it in a visually appealing way. It is written mainly in C, with a focus on performance and customizability. Currently, it supports Linux, macOS, Windows 7+, Android, FreeBSD, OpenBSD, NetBSD, DragonFly, Haiku and SunOS (illumos, Solaris).
+Fastfetch is a [neofetch](https://github.com/dylanaraps/neofetch)-like tool for fetching system information and displaying it in a visually appealing way. It is written mainly in C, with a focus on performance and customizability. Currently, it supports Linux, macOS, Windows 8.1+, Android, FreeBSD, OpenBSD, NetBSD, DragonFly, Haiku and SunOS (illumos, Solaris).
+
+> Note: Fastfetch is only actively tested on x86-64 and aarch64 platforms. It may work on other platforms but is not guaranteed to do so.
 
 <img src="screenshots/example1.png" width="49%" align="left" />
 <img src="https://upload.wikimedia.org/wikipedia/commons/2/24/Transparent_Square_Tiles_Texture.png" width="49%" height="16px" align="left" />
@@ -97,7 +100,7 @@ See the Wiki: https://github.com/fastfetch-cli/fastfetch/wiki/Building
 * View all data that fastfetch detects: `fastfetch -s <module1>[:<module2>][:<module3>] --format json`
 * Display help messages: `fastfetch --help`
 * Generate a minimal config file: `fastfetch [-s <module1>[:<module2>]] --gen-config [</path/to/config.jsonc>]`
-    * Use: `--gen-config-full` to generate a full config file with all optional options
+    * Use [The online configuration generator](https://fastfetch-cli.github.io/fastfetch-config/) to generate a full config file with all optional options
 
 ## Customization
 
@@ -197,7 +200,8 @@ See [#1096](https://github.com/fastfetch-cli/fastfetch/issues/1096).
 
 ### Q: Fastfetch shows fewer dpkg packages than neofetch. Is it a bug?
 
-Neofetch incorrectly counts `rc` packages (packages that have been removed but still have configuration files remaining). See bug: https://github.com/dylanaraps/neofetch/issues/2278
+1. Neofetch incorrectly counts `rc` packages for apt (packages that have been removed but still have configuration files remaining). See bug: https://github.com/dylanaraps/neofetch/issues/2278
+2. Neofetch incorrectly counts `gpg-pubkey` as packages for rpm. You may check the results of `dnf list --installed | wc -l` and `rpm -qa | wc -l` to see the difference.
 
 ### Q: I use Debian / Ubuntu / Debian-derived distro. My GPU is detected as `XXXX Device XXXX (VGA compatible)`. Is this a bug?
 
@@ -332,10 +336,10 @@ If you find Fastfetch useful, please consider donating.
 
 Give us a star to show your support!
 
-<a href="https://star-history.com/#fastfetch-cli/fastfetch&Date">
+<a href="https://star-history.dera.page/#fastfetch-cli/fastfetch&Date">
   <picture>
-    <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=fastfetch-cli/fastfetch&type=Date&theme=dark" />
-    <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=fastfetch-cli/fastfetch&type=Date" />
-    <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=fastfetch-cli/fastfetch&type=Date" />
+    <source media="(prefers-color-scheme: dark)" srcset="https://star-history.dera.page/svg?repos=fastfetch-cli/fastfetch&type=Date&theme=dark" />
+    <source media="(prefers-color-scheme: light)" srcset="https://star-history.dera.page/svg?repos=fastfetch-cli/fastfetch&type=Date" />
+    <img alt="Star History Chart" src="https://star-history.dera.page/svg?repos=fastfetch-cli/fastfetch&type=Date" />
   </picture>
 </a>

completions/fastfetch.fish

@@ -63,46 +63,78 @@ echo '
 import json, subprocess, sys
 
 
+def escape_fish_dq(s: str) -> str:
+    """Escape special characters for Fish double quotes to prevent unexpected expansions. One slash in output needs four slashes in script"""
+    return str(s).replace("\\\\", "\\\\\\\\").replace("\\"", "\\\\\\"").replace("$", "\\\\$")
+
+
 def main():
     data: dict[str, list[dict]] = json.loads(subprocess.check_output(["fastfetch", "--help-raw"]))
 
+    enum_functions = []
+    complete_commands = []
+
     for key in data:
         for flag in data[key]:
-            if flag["long"] == "logo-color-[1-9]":
+            long_name = flag.get("long", "")
+
+            # Handle pseudo flag logo-color-[1-9]
+            if long_name == "logo-color-[1-9]":
+                safe_desc_global = escape_fish_dq(flag.get("desc", ""))
                 for i in range(1, 10):
-                    print(f"""complete -c fastfetch -d "{flag["desc"]}" -l "logo-color-{i}" -x -a "(__fastfetch_complete_color)" """)
+                    complete_commands.append(f"complete -c fastfetch -d \"{safe_desc_global}\" -l \"logo-color-{i}\" -x -a \"(__fastfetch_complete_color)\"")
                 continue
 
             if flag.get("pseudo", False):
                 continue
 
-            command_prefix = f"""complete -c fastfetch -d "{flag["desc"]}" -l "{flag["long"]}\""""
+            safe_desc_global = escape_fish_dq(flag.get("desc", ""))
+            command_prefix = f"complete -c fastfetch -d \"{safe_desc_global}\" -l \"{long_name}\""
+
             if "short" in flag:
-                command_prefix += f""" -o {flag["short"]}"""
+                short_name = flag["short"]
+                command_prefix += f" -o {short_name}"
 
             if "arg" in flag:
-                type: str = flag["arg"]["type"]
-                if type == "bool":
-                    print(f"{command_prefix} -x -a \"(__fastfetch_complete_bool)\"")
-                elif type == "color":
-                    print(f"{command_prefix} -x -a \"(__fastfetch_complete_color)\"")
-                elif type == "command":
-                    print(f"{command_prefix} -x -a \"(__fastfetch_complete_command)\"")
-                elif type == "config":
-                    print(f"{command_prefix} -x -a \"(__fastfetch_complete_config)\"")
-                elif type == "enum":
-                    temp: str = " ".join(flag["arg"]["enum"])
-                    print(f"{command_prefix} -x -a \"{temp}\"")
-                elif type == "logo":
-                    print(f"{command_prefix} -x -a \"(__fastfetch_complete_logo)\"")
-                elif type == "structure":
-                    print(f"{command_prefix} -x -a \"(__fish_complete_list : __fastfetch_complete_structure)\"")
-                elif type == "path":
-                    print(f"{command_prefix} -r -F")
+                arg_type: str = flag["arg"]["type"]
+                if arg_type == "bool":
+                    complete_commands.append(f"{command_prefix} -x -a \"(__fastfetch_complete_bool)\"")
+                elif arg_type == "color":
+                    complete_commands.append(f"{command_prefix} -x -a \"(__fastfetch_complete_color)\"")
+                elif arg_type == "command":
+                    complete_commands.append(f"{command_prefix} -x -a \"(__fastfetch_complete_command)\"")
+                elif arg_type == "config":
+                    complete_commands.append(f"{command_prefix} -x -a \"(__fastfetch_complete_config)\"")
+                elif arg_type == "enum":
+                    # Sanitize flag name to create a valid Fish function name
+                    func_name = long_name.replace("-", "_").replace("[", "_").replace("]", "_")
+                    func_name = f"__fastfetch_complete_enum_{func_name}"
+
+                    # Generate the enum function
+                    func_lines = [f"function {func_name}"]
+                    for enum_val, enum_desc in flag["arg"]["enum"].items():
+                        safe_val = escape_fish_dq(enum_val)
+                        safe_desc = escape_fish_dq(enum_desc)
+                        func_lines.append(f"    echo -e \"{safe_val}\\t{safe_desc}\"")
+                    func_lines.append("end\n")
+                    enum_functions.append("\n".join(func_lines))
+
+                    # Append complete command pointing to the new function
+                    complete_commands.append(f"{command_prefix} -x -a \"({func_name})\"")
+                elif arg_type == "logo":
+                    complete_commands.append(f"{command_prefix} -x -a \"(__fastfetch_complete_logo)\"")
+                elif arg_type == "structure":
+                    complete_commands.append(f"{command_prefix} -x -a \"(__fish_complete_list : __fastfetch_complete_structure)\"")
+                elif arg_type == "path":
+                    complete_commands.append(f"{command_prefix} -r -F")
                 else:
-                    print(f"{command_prefix} -x")
+                    complete_commands.append(f"{command_prefix} -x")
             else:
-                print(f"{command_prefix} -f")
+                complete_commands.append(f"{command_prefix} -f")
+
+    # Print generated enum functions first, then complete rules
+    print("\n".join(enum_functions))
+    print("\n".join(complete_commands))
 
 
 if __name__ == "__main__":

debian/changelog.tpl

@@ -1,3 +1,63 @@
+fastfetch (2.67.0~#UBUNTU_CODENAME#) #UBUNTU_CODENAME#; urgency=medium
+
+  * Update to 2.67.0
+
+ -- Carter Li <zhangsongcui@live.cn>  Thu, 06 Aug 2026 16:22:22 +0800
+
+fastfetch (2.66.0~#UBUNTU_CODENAME#) #UBUNTU_CODENAME#; urgency=medium
+
+  * Update to 2.66.0
+
+ -- Carter Li <zhangsongcui@live.cn>  Fri, 10 Jul 2026 15:13:37 +0800
+
+fastfetch (2.65.2~#UBUNTU_CODENAME#) #UBUNTU_CODENAME#; urgency=medium
+
+  * Update to 2.65.2
+
+ -- Carter Li <zhangsongcui@live.cn>  Mon, 29 Jun 2026 10:05:47 +0800
+
+fastfetch (2.65.1~#UBUNTU_CODENAME#) #UBUNTU_CODENAME#; urgency=medium
+
+  * Update to 2.65.1
+
+ -- Carter Li <zhangsongcui@live.cn>  Wed, 24 Jun 2026 14:21:06 +0800
+
+fastfetch (2.64.2~#UBUNTU_CODENAME#) #UBUNTU_CODENAME#; urgency=medium
+
+  * Update to 2.64.2
+
+ -- Carter Li <zhangsongcui@live.cn>  Mon, 08 Jun 2026 15:45:11 +0800
+
+fastfetch (2.63.1~#UBUNTU_CODENAME#) #UBUNTU_CODENAME#; urgency=medium
+
+  * Update to 2.63.1
+
+ -- Carter Li <zhangsongcui@live.cn>  Fri, 15 May 2026 09:31:54 +0800
+
+fastfetch (2.63.0~#UBUNTU_CODENAME#) #UBUNTU_CODENAME#; urgency=medium
+
+  * Update to 2.63.0
+
+ -- Carter Li <zhangsongcui@live.cn>  Wed, 13 May 2026 16:02:28 +0800
+
+fastfetch (2.62.1~#UBUNTU_CODENAME#) #UBUNTU_CODENAME#; urgency=medium
+
+  * Update to 2.62.1
+
+ -- Carter Li <zhangsongcui@live.cn>  Fri, 24 Apr 2026 15:45:15 +0800
+
+fastfetch (2.62.0~#UBUNTU_CODENAME#) #UBUNTU_CODENAME#; urgency=medium
+
+  * Update to 2.62.0
+
+ -- Carter Li <zhangsongcui@live.cn>  Wed, 22 Apr 2026 09:49:55 +0800
+
+fastfetch (2.61.0~#UBUNTU_CODENAME#) #UBUNTU_CODENAME#; urgency=medium
+
+  * Update to 2.61.0
+
+ -- Carter Li <zhangsongcui@live.cn>  Mon, 30 Mar 2026 09:51:18 +0800
+
 fastfetch (2.58.0~#UBUNTU_CODENAME#) #UBUNTU_CODENAME#; urgency=medium
 
   * Update to 2.58.0

debian/control

@@ -2,7 +2,7 @@ Source: fastfetch
 Section: universe/utils
 Priority: optional
 Maintainer: Carter Li <zhangsongcui@live.cn>
-Build-Depends: libelf-dev, libvulkan-dev, libwayland-dev, libxrandr-dev, libxcb-randr0-dev, libdconf-dev, libdbus-1-dev, libmagickcore-dev, libsqlite3-dev, librpm-dev, libegl-dev, libglx-dev, ocl-icd-opencl-dev, libpulse-dev, libdrm-dev, libddcutil-dev, libchafa-dev, directx-headers-dev, pkgconf, cmake (>= 3.12), debhelper (>= 11.2), dh-cmake, dh-cmake-compat (= 1), dh-sequence-cmake, dh-sequence-ctest, ninja-build, python3-setuptools
+Build-Depends: libelf-dev, libvulkan-dev, libwayland-dev, libxrandr-dev, libxcb-randr0-dev, libdconf-dev, libdbus-1-dev, libmagickcore-dev, libsqlite3-dev, librpm-dev, libegl-dev, libglx-dev, ocl-icd-opencl-dev, libpulse-dev, libdrm-dev, libddcutil-dev, libchafa-dev, libefl-all-dev, pkgconf, cmake (>= 3.12), debhelper (>= 11.2), dh-cmake, dh-cmake-compat (= 1), dh-sequence-cmake, dh-sequence-ctest, ninja-build, python3-setuptools
 Standards-Version: 4.0.0
 Homepage: https://github.com/fastfetch-cli/fastfetch
 

debian/publish.sh

@@ -10,7 +10,7 @@ SCRIPT_DIR="$(cd -- "$(dirname "${BASH_SOURCE[0]}")" >/dev/null 2>&1 && pwd)"
 ROOT_DIR="$(cd -- "$SCRIPT_DIR/.." >/dev/null 2>&1 && pwd)"
 OUT_DIR="$(dirname "$ROOT_DIR")"
 PPA="ppa:zhangsongcui3371/fastfetch"
-CODENAMES=( jammy noble plucky questing resolute )
+CODENAMES=( jammy noble plucky questing resolute stonking )
 DRY_RUN=0
 
 if [[ -d "$OUT_DIR/build" ]]; then

doc/help.json

@@ -3,7 +3,7 @@
         {
             "short": "h",
             "long": "help",
-            "desc": "Display this help message or help for a specific command",
+            "desc": "Show this help message or help for a specific command",
             "arg": {
                 "type": "command",
                 "optional": true
@@ -12,11 +12,11 @@
         {
             "short": "v",
             "long": "version",
-            "desc": "Show the full version of fastfetch"
+            "desc": "Show the full Fastfetch version"
         },
         {
             "long": "version-raw",
-            "desc": "Display the raw version string (major.minor.patch)"
+            "desc": "Show the raw version string (major.minor.patch)"
         },
         {
             "long": "list-config-paths",
@@ -36,7 +36,7 @@
         },
         {
             "long": "list-presets",
-            "desc": "List presets that fastfetch knows about",
+            "desc": "List available presets",
             "remark": "Presets can be loaded with \"--config <preset-name>\""
         },
         {
@@ -46,15 +46,15 @@
         },
         {
             "long": "print-logos",
-            "desc": "Display available logos"
+            "desc": "Show available logos"
         },
         {
             "long": "print-structure",
-            "desc": "Display the default structure"
+            "desc": "Show the default structure"
         },
         {
             "long": "format",
-            "desc": "Set output format",
+            "desc": "Set the output format",
             "arg": {
                 "type": "enum",
                 "enum": {
@@ -77,12 +77,22 @@
         },
         {
             "long": "dynamic-interval",
-            "desc": "Keep fastfetch open and update the output every <num> milliseconds",
-            "remark": "0 (default) to disable the behavior; don't work with --json",
+            "desc": "Keep Fastfetch running and refresh the output every <num> milliseconds",
+            "remark": "Set to 0 (default) to disable this behavior; does not work with --json",
             "arg": {
                 "type": "num",
                 "default": 0
             }
+        },
+        {
+            "long": "watch",
+            "short": "w",
+            "desc": "Alias of dynamic-interval, but the value is in seconds instead of milliseconds. If no value is provided, it defaults to 1 second",
+            "arg": {
+                "type": "num",
+                "optional": true,
+                "default": 1
+            }
         }
     ],
     "Config": [
@@ -90,33 +100,15 @@
             "short": "c",
             "long": "config",
             "desc": "Specify the config file or preset to load",
-            "remark": "The file will be searched according to the order shown by \"fastfetch --list-config-paths\". Use \"-\" to read config from stdin or \"none\" to disable further config loading. See also https://github.com/fastfetch-cli/fastfetch/wiki/Configuration for more info",
+            "remark": "The file is searched in the order shown by \"fastfetch --list-config-paths\". Use \"-\" to read config from stdin, or \"none\" to disable further config loading. See also https://github.com/fastfetch-cli/fastfetch/wiki/Configuration for details",
             "arg": {
                 "type": "config"
             }
         },
         {
             "long": "gen-config",
-            "desc": "Generate a minimal config file at the specified path",
-            "remark": "Defaults to \"~/.config/fastfetch/config.jsonc\". Will print the generated config if <path> is \"-\"",
-            "arg": {
-                "type": "path",
-                "optional": true
-            }
-        },
-        {
-            "long": "gen-config-full",
-            "desc": "Generate a full config file with all optional options at the specified path",
-            "remark": "Defaults to \"~/.config/fastfetch/config.jsonc\". Will print the generated config if <path> is \"-\"",
-            "arg": {
-                "type": "path",
-                "optional": true
-            }
-        },
-        {
-            "long": "gen-config-force",
-            "desc": "Generate a config file at the specified path, overwriting any existing file",
-            "remark": "Defaults to \"~/.config/fastfetch/config.jsonc\"",
+            "desc": "Interactively generate a config file at the specified path",
+            "remark": "Opens an interactive configuration UI when run in a terminal. Falls back to non-interactive generation when env-var `$NO_COLOR` is set or stdin/stdout is not a TTY. Defaults to \"~/.config/fastfetch/config.jsonc\". Prints the generated config if <path> is \"-\"",
             "arg": {
                 "type": "path",
                 "optional": true
@@ -152,7 +144,7 @@
         },
         {
             "long": "ds-force-drm",
-            "desc": "Specify whether only DRM should be used to detect displays",
+            "desc": "Specify whether display detection should use DRM only",
             "remark": [
                 "Use this option if you encounter problems with other detection methods.",
                 "Linux only"
@@ -170,7 +162,7 @@
         },
         {
             "long": "detect-version",
-            "desc": "Specify whether to detect and display versions of terminal, shell, editor, and others",
+            "desc": "Specify whether to detect and display versions for terminal, shell, editor, and others",
             "remark": "Mainly for benchmarking",
             "arg": {
                 "type": "bool",
@@ -183,31 +175,31 @@
         {
             "short": "l",
             "long": "logo",
-            "desc": "Set the logo source. Use \"none\" to disable the logo",
-            "remark": "Should be the name of a built-in logo or a path to an image file. See also https://github.com/fastfetch-cli/fastfetch/wiki/Logo-options",
+            "desc": "Set the logo source. Use \"none\" to disable logo output",
+            "remark": "Use either a built-in logo name or a path to an image file. See also https://github.com/fastfetch-cli/fastfetch/wiki/Logo-options",
             "arg": {
                 "type": "logo"
             }
         },
         {
             "long": "logo-type",
-            "desc": "Set the type of the logo specified in \"--logo\"",
+            "desc": "Set the type of logo specified by \"--logo\"",
             "remark": "See also https://github.com/fastfetch-cli/fastfetch/wiki/Logo-options",
             "arg": {
                 "type": "enum",
                 "enum": {
-                    "auto": "If something is given, first try built-in, then file. Otherwise detect logo",
+                    "auto": "If a value is provided, try built-in first, then file. Otherwise auto-detect the logo",
                     "builtin": "Built-in ASCII art",
                     "small": "Built-in ASCII art, small version",
                     "file": "Text file, printed with color code replacement",
                     "file-raw": "Text file, printed as is",
                     "data": "Text data, printed with color code replacement",
                     "data-raw": "Text data, printed as is",
-                    "sixel": "Image file, printed as sixel codes",
-                    "kitty": "Image file, printed using kitty graphics protocol",
+                    "sixel": "Image file, rendered as sixel",
+                    "kitty": "Image file, rendered using the Kitty graphics protocol",
                     "kitty-direct": "Image file, tells the terminal emulator to read image data from the specified file",
-                    "kitty-icat": "Image file, uses `kitten icat` to display the image. Requires binary `kitten` to be installed",
-                    "iterm": "Image file, printed using iterm graphics protocol",
+                    "kitty-icat": "Image file, displayed using `kitten icat`. Requires the `kitten` binary",
+                    "iterm": "Image file, rendered using the iTerm graphics protocol",
                     "chafa": "Image file, printed as ASCII art using libchafa",
                     "raw": "Image file, printed as raw binary string",
                     "none": "Disable logo printing"
@@ -279,7 +271,7 @@
         },
         {
             "long": "logo-print-remaining",
-            "desc": "Specify whether to print the remaining logo if it has more lines than modules to display",
+            "desc": "Specify whether to print remaining logo lines when the logo is taller than the module list",
             "arg": {
                 "type": "bool",
                 "optional": true,
@@ -288,7 +280,7 @@
         },
         {
             "long": "logo-position",
-            "desc": "Set the position where the logo should be displayed",
+            "desc": "Set the display position of the logo",
             "arg": {
                 "type": "enum",
                 "enum": {
@@ -398,7 +390,7 @@
         {
             "long": "chafa-fg-only",
             "desc": "Produce character-cell output using foreground colors only",
-            "remark": "See chafa document for detail",
+            "remark": "See the Chafa documentation for details",
             "arg": {
                 "type": "bool",
                 "optional": true,
@@ -408,7 +400,7 @@
         {
             "long": "chafa-symbols",
             "desc": "Specify character symbols to employ in final output",
-            "remark": "See chafa document for detail",
+            "remark": "See the Chafa documentation for details",
             "arg": {
                 "type": "str"
             }
@@ -416,7 +408,7 @@
         {
             "long": "chafa-canvas-mode",
             "desc": "Determine how colors are used in the output",
-            "remark": "This value maps the int value of enum ChafaCanvasMode. See chafa document for detail",
+            "remark": "This value maps to the integer value of enum ChafaCanvasMode. See the Chafa documentation for details",
             "arg": {
                 "type": "enum",
                 "enum": {
@@ -433,8 +425,8 @@
         },
         {
             "long": "chafa-color-space",
-            "desc": "Set color space used for quantization",
-            "remark": "This value maps the int value of enum ChafaColorSpace. See chafa document for detail",
+            "desc": "Set the color space used for quantization",
+            "remark": "This value maps to the integer value of enum ChafaColorSpace. See the Chafa documentation for details",
             "arg": {
                 "type": "enum",
                 "enum": {
@@ -445,8 +437,8 @@
         },
         {
             "long": "chafa-dither-mode",
-            "desc": "Set output dither mode (No effect with 24-bit color)",
-            "remark": "This value maps the int value of enum ChafaDitherMode. See chafa document for detail",
+            "desc": "Set the output dithering mode (no effect with 24-bit color)",
+            "remark": "This value maps to the integer value of enum ChafaDitherMode. See the Chafa documentation for details",
             "arg": {
                 "type": "enum",
                 "enum": {
@@ -462,7 +454,7 @@
             "short": "s",
             "long": "structure",
             "desc": "Set the structure of the fetch",
-            "remark": "Must be a colon-separated list of keys. Use \"fastfetch --list-modules\" to see available options",
+            "remark": "Must be a colon-separated list of module keys. Use \"fastfetch --list-modules\" to see available options",
             "arg": {
                 "type": "structure",
                 "default": "\"fastfetch --print-structure\""
@@ -478,7 +470,7 @@
         },
         {
             "long": "stat",
-            "desc": "Show time usage (in ms) for individual modules",
+            "desc": "Show execution time (ms) for individual modules",
             "arg": {
                 "type": "bool",
                 "optional": true,
@@ -541,7 +533,7 @@
         {
             "long": "duration-abbreviation",
             "desc": "Specify whether to abbreviate duration values",
-            "remark": "If true, the output will be in the form of \"1h 2m\" instead of \"1 hour, 2 mins\"",
+            "remark": "If true, output is shown as \"1h 2m\" instead of \"1 hour, 2 mins\"",
             "arg": {
                 "type": "bool",
                 "optional": true,
@@ -582,7 +574,7 @@
                 "enum": {
                     "none": "Disable keys",
                     "string": "Show string",
-                    "icon": "Show icon (requires newest nerd font)",
+                    "icon": "Show icon (requires a recent Nerd Font)",
                     "both": "Show both icon and string (alias of `both-1`)",
                     "both-0": "Show both icon and string with no spaces between them",
                     "both-1": "Show both icon and string with a space between them",
@@ -593,6 +585,38 @@
                 "default": "string"
             }
         },
+        {
+            "long": "key-language",
+            "desc": "Specify the language used for module keys",
+            "remark": "Leave empty for auto-detection based on the system locale. Unsupported locales fall back to English",
+            "arg": {
+                "type": "enum",
+                "default": "en",
+                "optional": true,
+                "enum": {
+                    "en": "English",
+                    "ar": "Arabic",
+                    "cs": "Czech",
+                    "de": "German",
+                    "es": "Spanish",
+                    "fr": "French",
+                    "gl": "Galician",
+                    "he": "Hebrew",
+                    "id": "Indonesian",
+                    "it": "Italian",
+                    "ja": "Japanese",
+                    "ko": "Korean",
+                    "pl": "Polish",
+                    "pt": "Portuguese",
+                    "ru": "Russian",
+                    "tr": "Turkish",
+                    "uk": "Ukrainian",
+                    "vi": "Vietnamese",
+                    "zh_CN": "Simplified Chinese",
+                    "zh_TW": "Traditional Chinese"
+                }
+            }
+        },
         {
             "long": "bright-color",
             "desc": "Specify whether keys, title, and ASCII logo should be printed in bright color",
@@ -639,7 +663,7 @@
         },
         {
             "long": "percent-type",
-            "desc": "Set the percentage output type",
+            "desc": "Set the percentage output style",
             "remark": [
                 "1 for percentage number",
                 "2 for multi-color bar",
@@ -655,7 +679,7 @@
         },
         {
             "long": "percent-ndigits",
-            "desc": "Set the number of digits to keep after the decimal point when formatting percentage numbers",
+            "desc": "Set the number of decimal places to use when formatting percentages",
             "arg": {
                 "type": "num",
                 "default": 0
@@ -702,7 +726,7 @@
         },
         {
             "long": "percent-width",
-            "desc": "Specify the width of the percentage number, in number of characters",
+            "desc": "Specify the width of the percentage number, in characters",
             "remark": "This option affects only percentage numbers, not bars",
             "arg": {
                 "type": "num",
@@ -711,7 +735,7 @@
         },
         {
             "long": "bar-char-elapsed",
-            "desc": "Set the character to use in the elapsed part of percentage bars",
+            "desc": "Set the character used for the elapsed part of percentage bars",
             "arg": {
                 "type": "str",
                 "default": "\u25a0"
@@ -719,7 +743,7 @@
         },
         {
             "long": "bar-char-total",
-            "desc": "Set the character to use in the total part of percentage bars",
+            "desc": "Set the character used for the total part of percentage bars",
             "arg": {
                 "type": "str",
                 "default": "-"
@@ -743,7 +767,7 @@
         },
         {
             "long": "bar-border-left-elapsed",
-            "desc": "If both bar-border-left-elapsed and bar-border-right-elapsed are set, the border will be used as parts of bar content",
+            "desc": "If both bar-border-left-elapsed and bar-border-right-elapsed are set, the border is used as part of the bar content",
             "arg": {
                 "type": "string",
                 "default": ""
@@ -751,7 +775,7 @@
         },
         {
             "long": "bar-border-right-elapsed",
-            "desc": "If both bar-border-left-elapsed and bar-border-right-elapsed are set, the border will be used as parts of bar content",
+            "desc": "If both bar-border-left-elapsed and bar-border-right-elapsed are set, the border is used as part of the bar content",
             "arg": {
                 "type": "string",
                 "default": ""
@@ -759,8 +783,8 @@
         },
         {
             "long": "bar-color-elapsed",
-            "desc": "Set the color to use in the elapsed part of percentage bars",
-            "remark": "By default, auto selected by percent-color-{green,yellow,red}",
+            "desc": "Set the color used for the elapsed part of percentage bars",
+            "remark": "By default, this is auto-selected by percent-color-{green,yellow,red}",
             "arg": {
                 "type": "color",
                 "default": "<auto>"
@@ -768,7 +792,7 @@
         },
         {
             "long": "bar-color-total",
-            "desc": "Set the color to use in the total part of percentage bars",
+            "desc": "Set the color used for the total part of percentage bars",
             "arg": {
                 "type": "color",
                 "default": "light_white"
@@ -776,7 +800,7 @@
         },
         {
             "long": "bar-color-border",
-            "desc": "Set the color to use in the borders of percentage bars",
+            "desc": "Set the color used for percentage bar borders",
             "arg": {
                 "type": "color",
                 "default": "light_white"
@@ -792,7 +816,7 @@
         },
         {
             "long": "no-buffer",
-            "desc": "Specify whether the stdout application buffer should be disabled",
+            "desc": "Specify whether stdout buffering should be disabled",
             "arg": {
                 "type": "bool",
                 "optional": true,
@@ -801,7 +825,7 @@
         },
         {
             "long": "size-ndigits",
-            "desc": "Set the number of digits to keep after the decimal point when formatting sizes",
+            "desc": "Set the number of decimal places to use when formatting sizes",
             "arg": {
                 "type": "num"
             }
@@ -852,7 +876,7 @@
         },
         {
             "long": "freq-ndigits",
-            "desc": "Set the number of digits to keep after the decimal point when printing CPU/GPU frequency in GHz",
+            "desc": "Set the number of decimal places to use when printing CPU/GPU frequency in GHz",
             "arg": {
                 "type": "num",
                 "default": 2
@@ -872,7 +896,7 @@
         },
         {
             "long": "fraction-ndigits",
-            "desc": "Set the number of digits to keep after the decimal point when printing ordinary fraction numbers",
+            "desc": "Set the number of decimal places to use when printing fractional values",
             "remark": "If negative, the number of digits will be automatically determined based on the value",
             "arg": {
                 "type": "num",
@@ -885,7 +909,7 @@
             "arg": {
                 "type": "enum",
                 "enum": {
-                    "default": "Use the behavior defined internally",
+                    "default": "Use the built-in behavior",
                     "always": "Always keep trailing zeros",
                     "never": "Never keep trailing zeros"
                 }
@@ -907,7 +931,7 @@
         },
         {
             "long": "temp-ndigits",
-            "desc": "Set the number of digits to keep after the decimal point when printing temperature",
+            "desc": "Set the number of decimal places to use when printing temperatures",
             "arg": {
                 "type": "num",
                 "default": 2

presets/all.jsonc

@@ -50,6 +50,10 @@
             "driverSpecific": true,
             "temp": true
         },
+        {
+            "type": "codec",
+            "splitGPU": true
+        },
         "memory",
         "physicalmemory",
         {
@@ -95,16 +99,17 @@
         "gamepad",
         "mouse",
         "keyboard",
-        {
-          "type": "weather",
-          "timeout": 1000
-        },
+        "top",
         "netio",
         "diskio",
         {
             "type": "physicaldisk",
             "temp": true
         },
+        {
+          "type": "weather",
+          "timeout": 1000
+        },
         "tpm",
         "version",
         "break",

presets/ci.jsonc

@@ -52,6 +52,10 @@
             "driverSpecific": true,
             "temp": true
         },
+        {
+            "type": "codec",
+            "splitGPU": true
+        },
         "memory",
         "physicalmemory",
         {
@@ -90,23 +94,24 @@
         "opengl",
         "opencl",
         "users",
-        // "bluetooth", // doesn't work on macOS because it requires bluetooth permissions
-        // "bluetoothradio",
+        "bluetooth",
+        "bluetoothradio",
         "sound",
         "camera",
         "gamepad",
         "mouse",
         "keyboard",
-        {
-            "type": "weather",
-            "timeout": 1000
-        },
+        "top",
         "netio",
         "diskio",
         {
             "type": "physicaldisk",
             "temp": true
         },
+        {
+            "type": "weather",
+            "timeout": 1000
+        },
         "tpm",
         "version",
         "logo",

presets/examples/10.jsonc

@@ -1,6 +1,3 @@
-// Load with --config examples/2.jsonc
-// Note that you must replace the image path to an existing image to display it.
-
 {
     "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
     "logo": {
@@ -45,12 +42,12 @@
         },
         {
             "type": "kernel",
-            "key": "│ ├",
+            "key": "│ ├{icon}",
             "keyColor": "yellow"
         },
         {
             "type": "packages",
-            "key": "│ ├󰏖",
+            "key": "│ ├{icon}",
             "keyColor": "yellow"
         },
         {
@@ -65,22 +62,22 @@
         },
         {
             "type": "lm",
-            "key": "│ ├󰧨",
+            "key": "│ ├{icon}",
             "keyColor": "blue"
         },
         {
             "type": "wmtheme",
-            "key": "│ ├󰉼",
+            "key": "│ ├{icon}",
             "keyColor": "blue"
         },
         {
             "type": "icons",
-            "key": "│ ├󰀻",
+            "key": "│ ├{icon}",
             "keyColor": "blue"
         },
         {
             "type": "terminal",
-            "key": "│ ├",
+            "key": "│ ├{icon}",
             "keyColor": "blue"
         },
         {
@@ -95,32 +92,32 @@
         },
         {
             "type": "cpu",
-            "key": "│ ├󰻠",
+            "key": "│ ├{icon}",
             "keyColor": "green"
         },
         {
             "type": "gpu",
-            "key": "│ ├󰍛",
+            "key": "│ ├{icon}",
             "keyColor": "green"
         },
         {
             "type": "disk",
-            "key": "│ ├",
+            "key": "│ ├{icon}",
             "keyColor": "green"
         },
         {
             "type": "memory",
-            "key": "│ ├󰑭",
+            "key": "│ ├{icon}",
             "keyColor": "green"
         },
         {
             "type": "swap",
-            "key": "│ ├󰓡",
+            "key": "│ ├{icon}",
             "keyColor": "green"
         },
         {
             "type": "uptime",
-            "key": "│ ├󰅐",
+            "key": "│ ├{icon}",
             "keyColor": "green"
         },
         {
@@ -135,7 +132,7 @@
         },
         {
             "type": "player",
-            "key": "│ ├󰥠",
+            "key": "│ ├{icon}",
             "keyColor": "cyan"
         },
         {

presets/examples/13.jsonc

@@ -1,4 +1,4 @@
-// Inspired by Catnap
+// Inspired by Catnap (https://github.com/iinsertNameHere/catnap)
 {
     "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
     "logo": {

presets/examples/14.jsonc

@@ -1,4 +1,4 @@
-// Inspired by Catnap
+// Inspired by Catnap (https://github.com/iinsertNameHere/catnap)
 {
     "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
     "logo": {
@@ -12,7 +12,7 @@
     },
     "modules": [
         {
-            // draw borders first to make colors of left and right border consistant
+            // draw borders first to make colors of left and right border consistent
             "key": " user",
             "type": "title",
             "format": "{user-name}",

presets/examples/15.jsonc

@@ -1,4 +1,4 @@
-// Inspired by Catnap
+// Inspired by Catnap (https://github.com/iinsertNameHere/catnap)
 {
     "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
     "logo": {

presets/examples/16.jsonc

@@ -1,4 +1,4 @@
-// Inspired by Catnap
+// Inspired by Catnap (https://github.com/iinsertNameHere/catnap)
 {
     "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
     "logo": {

presets/examples/6.jsonc

@@ -1,6 +1,3 @@
-// Load with --config examples/2.jsonc
-// Note that you must replace the image path to an existing image to display it.
-
 {
     "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
     "display": {

presets/examples/7.jsonc

@@ -1,6 +1,3 @@
-// Load with --config examples/2.jsonc
-// Note that you must replace the image path to an existing image to display it.
-
 {
     "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
     "logo": {

presets/neofetch.jsonc

@@ -16,6 +16,13 @@
         "separator",
         "os",
         "host",
+        {
+            "type": "board",
+            "key": "Host",
+            "condition": {
+                "succeeded": false
+            }
+        },
         {
             "type": "kernel",
             "format": "{release}"

scripts/gen-amdgpuids.py

@@ -6,6 +6,9 @@ def main(amdgpu_ids_path: str):
     with open(amdgpu_ids_path, 'r') as f:
         full_text = f.read()
 
+    if full_text == '':
+        sys.exit(f'Error: {amdgpu_ids_path} file is empty')
+
     products = []
     for line in full_text.split('\n'):
         if not line or line[0] == '#' or not ',\t' in line:

scripts/gen-man.py

@@ -33,7 +33,7 @@ endBold = r"\fR" # end bold text tag
 # path to the current directory
 pathToCurrentDir = path.dirname(__file__)
 # path to the JSON option file
-pathToHelpFile = path.join(pathToCurrentDir, "../src/data/help.json")
+pathToHelpFile = path.join(pathToCurrentDir, "../doc/help.json")
 # man page section
 manSection = 1
 # title (center header)

scripts/gen-pciids.py

@@ -18,6 +18,9 @@ def main(keep_vendor_list: set, pci_ids_path: str):
     with open(pci_ids_path, 'r') as f:
         full_text = f.read()
 
+    if full_text == '':
+        sys.exit(f'Error: {pci_ids_path} file is empty')
+
     dev_list_text = full_text[:full_text.rfind('\n\n\n')]  # remove known classes
     for line in dev_list_text.split('\n'):
         if not line or line[0] == '#':

src/3rdparty/display-library/adl_defines.h

@@ -21,7 +21,7 @@
 // SOFTWARE.
 
 /// \file adl_defines.h
-/// \brief Contains all definitions exposed by ADL for \ALL platforms.\n <b>Included in ADL SDK</b>
+/// \brief Contains all definitions exposed by ADL for \WIN platforms.\n <b>Included in ADL SDK</b>
 ///
 /// This file contains all definitions used by ADL.
 /// The ADL definitions include the following:
@@ -61,6 +61,8 @@
 #define ADL_ADAPTER_INDEX_ALL                            -1
 ///    Defines APIs with iOption none
 #define ADL_MAIN_API_OPTION_NONE                        0
+///    Defines the maximum of RPC endpoint
+#define ADL_MAX_RPC_ENDPOINT                        32
 /// @}
 
 /// \name Definitions for iOption parameter used by
@@ -141,6 +143,12 @@
 #define ADL_ERR_FEATURESYNC_NOT_STARTED            -24
 /// Adapter is in an invalid power state
 #define ADL_ERR_INVALID_POWER_STATE             -25
+/// The RPC server is in busy state
+#define ADL_ERR_SERVER_BUSY             -26
+/// The GPU is occupied by application which cannot be powered off
+#define ADL_ERR_GPU_IN_USE            -27
+/// The general RPC connection error
+#define ADL_ERR_RPC            -28
 
 /// @}
 /// </A>
@@ -380,6 +388,7 @@
 #define ADL_BUSTYPE_PCIE_GEN2     3       /* PCI Express 2nd generation bus   */
 #define ADL_BUSTYPE_PCIE_GEN3     4       /* PCI Express 3rd generation bus   */
 #define ADL_BUSTYPE_PCIE_GEN4     5       /* PCI Express 4th generation bus   */
+#define ADL_BUSTYPE_PCIE_GEN5     6       /* PCI Express 5th generation bus   */
 /// @}
 
 /// \defgroup define_ws_caps    Workstation Capabilities
@@ -872,7 +881,7 @@
 typedef enum ADLThreadingModel
 {
     ADL_THREADING_UNLOCKED    = 0, /*!< Default behavior. ADL will not enforce serialization of ADL API executions by multiple threads.  Multiple threads will be allowed to enter to ADL at the same time. Note that ADL library is not guaranteed to be thread-safe. Client that calls ADL_Main_Control_Create have to provide its own mechanism for ADL calls serialization. */
-    ADL_THREADING_LOCKED     /*!< ADL will enforce serialization of ADL API when called by multiple threads.  Only single thread will be allowed to enter ADL API at the time. This option makes ADL calls thread-safe. You shouldn't use this option if ADL calls will be executed on Linux on x-server rendering thread. It can cause the application to hung.  */
+    ADL_THREADING_LOCKED     /*!< ADL will enforce serialization of ADL API when called by multiple threads.  Only single thread will be allowed to enter ADL API at the time. This option makes ADL calls thread-safe. */
 }ADLThreadingModel;
 
 /// @}
@@ -1844,12 +1853,12 @@ enum ADLOD8FeatureControl
     ADL_OD8_TEMPERATURE_FAN = 1 << 6,   //FanTargetTemperature
     ADL_OD8_TEMPERATURE_SYSTEM = 1 << 7,    //MaxOpTemp
     ADL_OD8_MEMORY_TIMING_TUNE = 1 << 8,
-    ADL_OD8_FAN_ZERO_RPM_CONTROL = 1 << 9 ,
-	ADL_OD8_AUTO_UV_ENGINE = 1 << 10,  //Auto under voltage
-	ADL_OD8_AUTO_OC_ENGINE = 1 << 11,  //Auto overclock engine
-	ADL_OD8_AUTO_OC_MEMORY = 1 << 12,  //Auto overclock memory
-	ADL_OD8_FAN_CURVE = 1 << 13,   //Fan curve
-	ADL_OD8_WS_AUTO_FAN_ACOUSTIC_LIMIT = 1 << 14, //Workstation Manual Fan controller
+    ADL_OD8_FAN_ZERO_RPM_CONTROL = 1 << 9,
+    ADL_OD8_AUTO_UV_ENGINE = 1 << 10,  //Auto under voltage
+    ADL_OD8_AUTO_OC_ENGINE = 1 << 11,  //Auto overclock engine
+    ADL_OD8_AUTO_OC_MEMORY = 1 << 12,  //Auto overclock memory
+    ADL_OD8_FAN_CURVE = 1 << 13,   //Fan curve
+    ADL_OD8_WS_AUTO_FAN_ACOUSTIC_LIMIT = 1 << 14, //Workstation Manual Fan controller
     ADL_OD8_GFXCLK_QUADRATIC_CURVE = 1 << 15,
     ADL_OD8_OPTIMIZED_GPU_POWER_MODE = 1 << 16,
     ADL_OD8_ODVOLTAGE_LIMIT = 1 << 17,
@@ -1860,43 +1869,45 @@ enum ADLOD8FeatureControl
     ADL_OD8_TDC_LIMIT = 1 << 22,  //TDC slider
     ADL_OD8_FULL_CONTROL_MODE = 1 << 23,  //Full control
     ADL_OD8_POWER_SAVING_FEATURE_CONTROL = 1 << 24,  //Power saving feature control
-    ADL_OD8_POWER_GAUGE = 1 << 25 //Power Gauge
+    ADL_OD8_ACTIMING_PARAMETERS_TUNE = 1 << 25,  // AC Timing Parameters Tuning
+    ADL_OD8_OVERDRIVE_INTERFACE = 1 << 26,  // Version info feature ID for RSX, do not expose in ADL.
+    ADL_OD8_AUTO_UV_ENGINE_V2 = 1 << 27,  // Auto UV 2.0 with actual stress testing.
+    ADL_OD8_POWER_GAUGE = 1 << 28 //Power Gauge
 };
 
-
 typedef enum ADLOD8SettingId
 {
-	OD8_GFXCLK_FMAX = 0,
-	OD8_GFXCLK_FMIN,
-	OD8_GFXCLK_FREQ1,
-	OD8_GFXCLK_VOLTAGE1,
-	OD8_GFXCLK_FREQ2,
-	OD8_GFXCLK_VOLTAGE2,
-	OD8_GFXCLK_FREQ3,
-	OD8_GFXCLK_VOLTAGE3,
-	OD8_UCLK_FMAX,
-	OD8_POWER_PERCENTAGE,
-	OD8_FAN_MIN_SPEED,
-	OD8_FAN_ACOUSTIC_LIMIT,
-	OD8_FAN_TARGET_TEMP,
-	OD8_OPERATING_TEMP_MAX,
-	OD8_AC_TIMING,
-	OD8_FAN_ZERORPM_CONTROL,
-	OD8_AUTO_UV_ENGINE_CONTROL,
-	OD8_AUTO_OC_ENGINE_CONTROL,
-	OD8_AUTO_OC_MEMORY_CONTROL,
-	OD8_FAN_CURVE_TEMPERATURE_1,
-	OD8_FAN_CURVE_SPEED_1,
-	OD8_FAN_CURVE_TEMPERATURE_2,
-	OD8_FAN_CURVE_SPEED_2,
-	OD8_FAN_CURVE_TEMPERATURE_3,
-	OD8_FAN_CURVE_SPEED_3,
-	OD8_FAN_CURVE_TEMPERATURE_4,
-	OD8_FAN_CURVE_SPEED_4,
-	OD8_FAN_CURVE_TEMPERATURE_5,
-	OD8_FAN_CURVE_SPEED_5,
-	OD8_WS_FAN_AUTO_FAN_ACOUSTIC_LIMIT,
-    OD8_GFXCLK_CURVE_COEFFICIENT_A, // As part of the agreement with UI team, the min/max voltage limits for the
+    OD8_GFXCLK_FMAX = 0,
+    OD8_GFXCLK_FMIN,
+    OD8_GFXCLK_FREQ1,
+    OD8_GFXCLK_VOLTAGE1,
+    OD8_GFXCLK_FREQ2,
+    OD8_GFXCLK_VOLTAGE2,
+    OD8_GFXCLK_FREQ3,
+    OD8_GFXCLK_VOLTAGE3,
+    OD8_UCLK_FMAX,
+    OD8_POWER_PERCENTAGE,
+    OD8_FAN_MIN_SPEED, //10
+    OD8_FAN_ACOUSTIC_LIMIT,
+    OD8_FAN_TARGET_TEMP,
+    OD8_OPERATING_TEMP_MAX,
+    OD8_AC_TIMING,
+    OD8_FAN_ZERORPM_CONTROL,
+    OD8_AUTO_UV_ENGINE_CONTROL,
+    OD8_AUTO_OC_ENGINE_CONTROL,
+    OD8_AUTO_OC_MEMORY_CONTROL,
+    OD8_FAN_CURVE_TEMPERATURE_1,
+    OD8_FAN_CURVE_SPEED_1, //20
+    OD8_FAN_CURVE_TEMPERATURE_2,
+    OD8_FAN_CURVE_SPEED_2,
+    OD8_FAN_CURVE_TEMPERATURE_3,
+    OD8_FAN_CURVE_SPEED_3,
+    OD8_FAN_CURVE_TEMPERATURE_4,
+    OD8_FAN_CURVE_SPEED_4,
+    OD8_FAN_CURVE_TEMPERATURE_5,
+    OD8_FAN_CURVE_SPEED_5,
+    OD8_WS_FAN_AUTO_FAN_ACOUSTIC_LIMIT,
+    OD8_GFXCLK_CURVE_COEFFICIENT_A, // 30 As part of the agreement with UI team, the min/max voltage limits for the
     OD8_GFXCLK_CURVE_COEFFICIENT_B, // quadratic curve graph will be stored in the min and max limits of
     OD8_GFXCLK_CURVE_COEFFICIENT_C, // coefficient a, b and c. A, b and c themselves do not have limits.
     OD8_GFXCLK_CURVE_VFT_FMIN,
@@ -1906,7 +1917,7 @@ typedef enum ADLOD8SettingId
     OD8_OD_VOLTAGE,// RSX - voltage offset feature
     OD8_ADV_OC_LIMITS_SETTING,
     OD8_PER_ZONE_GFX_VOLTAGE_OFFSET_POINT_1,
-    OD8_PER_ZONE_GFX_VOLTAGE_OFFSET_POINT_2,
+    OD8_PER_ZONE_GFX_VOLTAGE_OFFSET_POINT_2, //40
     OD8_PER_ZONE_GFX_VOLTAGE_OFFSET_POINT_3,
     OD8_PER_ZONE_GFX_VOLTAGE_OFFSET_POINT_4,
     OD8_PER_ZONE_GFX_VOLTAGE_OFFSET_POINT_5,
@@ -1915,8 +1926,33 @@ typedef enum ADLOD8SettingId
     OD8_GFX_VOLTAGE_LIMIT_SETTING,
     OD8_TDC_PERCENTAGE,
     OD8_FULL_CONTROL_MODE_SETTING,
+    OD8_FULL_CONTROL_MODE_GFXCLK,
+    OD8_FULL_CONTROL_MODE_UCLK,               // 50,
     OD8_IDLE_POWER_SAVING_FEATURE_CONTROL,
     OD8_RUNTIME_POWER_SAVING_FEATURE_CONTROL,
+    OD8_FULL_CONTROL_MODE_FEATURE_CONTROL,
+    OD8_PER_ZONE_GFX_VOLTAGE_OFFSET_FREQ_ANCHOR_1,
+    OD8_PER_ZONE_GFX_VOLTAGE_OFFSET_FREQ_ANCHOR_2,
+    OD8_PER_ZONE_GFX_VOLTAGE_OFFSET_FREQ_ANCHOR_3,
+    OD8_PER_ZONE_GFX_VOLTAGE_OFFSET_FREQ_ANCHOR_4,
+    OD8_PER_ZONE_GFX_VOLTAGE_OFFSET_FREQ_ANCHOR_5,
+    OD8_PER_ZONE_GFX_VOLTAGE_OFFSET_FREQ_ANCHOR_6,
+    OD8_PER_ZONE_GFX_VOLTAGE_OFFSET_VOLTAGE_LIMIT, //60
+    OD8_ACTIMING_PARAMETER_TRRDS,
+    OD8_ACTIMING_PARAMETER_TCL,
+    OD8_ACTIMING_PARAMETER_TCWL,
+    OD8_ACTIMING_PARAMETER_TRCDRD,
+    OD8_ACTIMING_PARAMETER_TRCDWR,
+    OD8_ACTIMING_PARAMETER_TRAS,
+    OD8_ACTIMING_PARAMETER_TRPAB,
+    OD8_ACTIMING_PARAMETER_TRFC,
+    OD8_ACTIMING_PARAMETER_TRFCPB,
+    OD8_ACTIMING_PARAMETER_TRREFD, //70
+    OD8_ACTIMING_PARAMETER_TREF,
+    OD8_ACTIMING_PARAMETER_TWR,
+    OD8_ACTIMING_PARAMETER_TWTRS,
+    OD8_OVERDRIVE_INTERFACE_ID, //74
+    OD8_AUTO_UV_ENGINE_V2_ID,   //75
     OD8_POWER_GAUGE,
     OD8_COUNT
 } ADLOD8SettingId;
@@ -1980,28 +2016,28 @@ typedef enum ADLSensorType
     PMLOG_SSDGPU_POWERLIMIT     = 49, // DGPU Power limit
     PMLOG_TEMPERATURE_HOTSPOT_GCD      = 50,
     PMLOG_TEMPERATURE_HOTSPOT_MCD      = 51,
-    PMLOG_THROTTLER_TEMP_EDGE_PERCENTAGE        = 52,
-    PMLOG_THROTTLER_TEMP_HOTSPOT_PERCENTAGE     = 53,
-    PMLOG_THROTTLER_TEMP_HOTSPOT_GCD_PERCENTAGE = 54,
-    PMLOG_THROTTLER_TEMP_HOTSPOT_MCD_PERCENTAGE = 55,
-    PMLOG_THROTTLER_TEMP_MEM_PERCENTAGE     = 56,
-    PMLOG_THROTTLER_TEMP_VR_GFX_PERCENTAGE  = 57,
-    PMLOG_THROTTLER_TEMP_VR_MEM0_PERCENTAGE = 58,
-    PMLOG_THROTTLER_TEMP_VR_MEM1_PERCENTAGE = 59,
-    PMLOG_THROTTLER_TEMP_VR_SOC_PERCENTAGE  = 60,
-    PMLOG_THROTTLER_TEMP_LIQUID0_PERCENTAGE = 61,
-    PMLOG_THROTTLER_TEMP_LIQUID1_PERCENTAGE = 62,
-    PMLOG_THROTTLER_TEMP_PLX_PERCENTAGE = 63,
-    PMLOG_THROTTLER_TDC_GFX_PERCENTAGE  = 64,
-    PMLOG_THROTTLER_TDC_SOC_PERCENTAGE  = 65,
-    PMLOG_THROTTLER_TDC_USR_PERCENTAGE  = 66,
-    PMLOG_THROTTLER_PPT0_PERCENTAGE     = 67,
-    PMLOG_THROTTLER_PPT1_PERCENTAGE     = 68,
-    PMLOG_THROTTLER_PPT2_PERCENTAGE     = 69,
-    PMLOG_THROTTLER_PPT3_PERCENTAGE     = 70,
-    PMLOG_THROTTLER_FIT_PERCENTAGE           = 71,
-    PMLOG_THROTTLER_GFX_APCC_PLUS_PERCENTAGE = 72,
-    PMLOG_BOARD_POWER                        = 73,
+    PMLOG_THROTTLE_PERCENTAGE_TEMP_GFX = 52,
+    PMLOG_THROTTLE_PERCENTAGE_TEMP_MEM = 53,
+    PMLOG_THROTTLE_PERCENTAGE_TEMP_VR = 54,
+    PMLOG_THROTTLE_PERCENTAGE_POWER = 55,
+    PMLOG_THROTTLE_PERCENTAGE_TDC = 56,
+    PMLOG_THROTTLE_PERCENTAGE_VMAX = 57,
+    PMLOG_BUS_CURR_MAX_SPEED = 58, 
+    PMLOG_RESERVED_1 = 59, //Currently Unused
+    PMLOG_RESERVED_2 = 60, //Currently Unused
+    PMLOG_RESERVED_3 = 61, //Currently Unused
+    PMLOG_RESERVED_4 = 62, //Currently Unused
+    PMLOG_RESERVED_5 = 63, //Currently Unused
+    PMLOG_RESERVED_6 = 64, //Currently Unused
+    PMLOG_RESERVED_7 = 65, //Currently Unused
+    PMLOG_RESERVED_8 = 66, //Currently Unused
+    PMLOG_RESERVED_9 = 67, //Currently Unused
+    PMLOG_RESERVED_10 = 68, //Currently Unused
+    PMLOG_RESERVED_11 = 69, //Currently Unused
+    PMLOG_RESERVED_12 = 70, //Currently Unused
+    PMLOG_RESERVED_13 = 71, //Currently Unused
+    PMLOG_RESERVED_14 = 72,
+    PMLOG_BOARD_POWER = 73,
     PMLOG_MAX_SENSORS_REAL
 } ADLSensorType;
 
@@ -2068,28 +2104,29 @@ typedef enum ADL_PMLOG_SENSORS
     ADL_PMLOG_SSDGPU_POWERLIMIT     = 49, // DGPU Power limit
     ADL_PMLOG_TEMPERATURE_HOTSPOT_GCD      = 50,
     ADL_PMLOG_TEMPERATURE_HOTSPOT_MCD      = 51,
-    ADL_PMLOG_THROTTLER_TEMP_EDGE_PERCENTAGE        = 52,
-    ADL_PMLOG_THROTTLER_TEMP_HOTSPOT_PERCENTAGE     = 53,
-    ADL_PMLOG_THROTTLER_TEMP_HOTSPOT_GCD_PERCENTAGE = 54,
-    ADL_PMLOG_THROTTLER_TEMP_HOTSPOT_MCD_PERCENTAGE = 55,
-    ADL_PMLOG_THROTTLER_TEMP_MEM_PERCENTAGE     = 56,
-    ADL_PMLOG_THROTTLER_TEMP_VR_GFX_PERCENTAGE  = 57,
-    ADL_PMLOG_THROTTLER_TEMP_VR_MEM0_PERCENTAGE = 58,
-    ADL_PMLOG_THROTTLER_TEMP_VR_MEM1_PERCENTAGE = 59,
-    ADL_PMLOG_THROTTLER_TEMP_VR_SOC_PERCENTAGE  = 60,
-    ADL_PMLOG_THROTTLER_TEMP_LIQUID0_PERCENTAGE = 61,
-    ADL_PMLOG_THROTTLER_TEMP_LIQUID1_PERCENTAGE = 62,
-    ADL_PMLOG_THROTTLER_TEMP_PLX_PERCENTAGE = 63,
-    ADL_PMLOG_THROTTLER_TDC_GFX_PERCENTAGE  = 64,
-    ADL_PMLOG_THROTTLER_TDC_SOC_PERCENTAGE  = 65,
-    ADL_PMLOG_THROTTLER_TDC_USR_PERCENTAGE  = 66,
-    ADL_PMLOG_THROTTLER_PPT0_PERCENTAGE     = 67,
-    ADL_PMLOG_THROTTLER_PPT1_PERCENTAGE     = 68,
-    ADL_PMLOG_THROTTLER_PPT2_PERCENTAGE     = 69,
-    ADL_PMLOG_THROTTLER_PPT3_PERCENTAGE     = 70,
-    ADL_PMLOG_THROTTLER_FIT_PERCENTAGE           = 71,
-    ADL_PMLOG_THROTTLER_GFX_APCC_PLUS_PERCENTAGE = 72,
-    ADL_PMLOG_BOARD_POWER                        = 73,
+    ADL_PMLOG_THROTTLE_PERCENTAGE_TEMP_GFX = 52,
+    ADL_PMLOG_THROTTLE_PERCENTAGE_TEMP_MEM = 53,
+    ADL_PMLOG_THROTTLE_PERCENTAGE_TEMP_VR = 54,
+    ADL_PMLOG_THROTTLE_PERCENTAGE_POWER = 55,
+    ADL_PMLOG_THROTTLE_PERCENTAGE_TDC = 56,
+    ADL_PMLOG_THROTTLE_PERCENTAGE_VMAX = 57,
+    ADL_PMLOG_BUS_CURR_MAX_SPEED = 58, 
+    ADL_PMLOG_RESERVED_1 = 59, //Currently Unused
+    ADL_PMLOG_RESERVED_2 = 60, //Currently Unused
+    ADL_PMLOG_RESERVED_3 = 61, //Currently Unused
+    ADL_PMLOG_RESERVED_4 = 62, //Currently Unused
+    ADL_PMLOG_RESERVED_5 = 63, //Currently Unused
+    ADL_PMLOG_RESERVED_6 = 64, //Currently Unused
+    ADL_PMLOG_RESERVED_7 = 65, //Currently Unused
+    ADL_PMLOG_RESERVED_8 = 66, //Currently Unused
+    ADL_PMLOG_RESERVED_9 = 67, //Currently Unused
+    ADL_PMLOG_RESERVED_10 = 68, //Currently Unused
+    ADL_PMLOG_RESERVED_11 = 69, //Currently Unused
+    ADL_PMLOG_RESERVED_12 = 70, //Currently Unused
+    ADL_PMLOG_CLK_NPUCLK = 71,      //NPU frequency
+    ADL_PMLOG_NPU_BUSY_AVG = 72,    //NPU busy
+    ADL_PMLOG_BOARD_POWER = 73,
+    ADL_PMLOG_TEMPERATURE_INTAKE = 74,
     ADL_PMLOG_MAX_SENSORS_REAL
 } ADL_PMLOG_SENSORS;
 
@@ -2393,6 +2430,9 @@ typedef enum ADL_PMLOG_SENSORS
 /// Indicates there is crossGPU clone
 #define ADL_CROSSGPUDISPLAYCLONE                  0x2
 
+
+/// @}
+
 /// @}
 
 /// \defgroup define_D3DKMT_HANDLE
@@ -2493,7 +2533,11 @@ typedef enum ADL_UIFEATURES_GROUP
 	ADL_UIFEATURES_GROUP_PROVSR = 12,
     ADL_UIFEATURES_GROUP_SMA = 13,
     ADL_UIFEATURES_GROUP_CAMERA = 14,
-    ADL_UIFEATURES_GROUP_FRTCPRO = 15
+    ADL_UIFEATURES_GROUP_FRTCPRO = 15,
+    ADL_UIFEATURES_GROUP_DELAGNEXT = 16,
+    ADL_UIFEATURES_GROUP_RTBOOST = 17,
+    ADL_UIFEATURES_GROUP_UAI = 18
+
 } ADL_UIFEATURES_GROUP;
 
 
@@ -2587,9 +2631,18 @@ typedef enum ADL_USER_SETTINGS
     ADL_USER_SETTINGS_USU_PROFILE = 1 << 4,  		//notify USU settings change
     ADL_USER_SETTINGS_CVDC_PROFILE = 1 << 5,			//notify Color Vision Deficiency Corretion settings change
     ADL_USER_SETTINGS_SCE_PROFILE = 1 << 6,
-    ADL_USER_SETTINGS_PROVSR = 1 << 7
+    ADL_USER_SETTINGS_PROVSR = 1 << 7,
+    ADL_USER_SETTINGS_RTBOOST_PROFILE=1 << 8,
+    ADL_USER_SETTINGS_USU2_PROFILE = 1 << 9,  		//notify USU2 settings change
    } ADL_USER_SETTINGS;
 
+//FRAME_TIMESTAMPS_SHARED_MEMORY type
+typedef enum FRAME_TIMESTAMPS_SHARED_MEMORY_TYPE
+{
+    FRAME_TIMESTAMPS_SHARED_MEMORY_TYPE_UNKNOWN = 0,
+    FRAME_TIMESTAMPS_SHARED_MEMORY_TYPE_LEGACY,
+    FRAME_TIMESTAMPS_SHARED_MEMORY_TYPE_INDEXED
+}FRAME_TIMESTAMPS_SHARED_MEMORY_TYPE;
 #define ADL_REG_DEVICE_FUNCTION_1            0x00000001
 #endif /* ADL_DEFINES_H_ */
 

src/3rdparty/display-library/adl_sdk.h

@@ -33,14 +33,10 @@
 
 #include "adl_structures.h"
 
-#if defined (LINUX)
-#define __stdcall
-#endif /* (LINUX) */
-
 /// Memory Allocation Call back 
 typedef void* ( __stdcall *ADL_MAIN_MALLOC_CALLBACK )( int );
 
-#define ADL_SDK_MAJOR_VERSION 17
-#define ADL_SDK_MINOR_VERSION 1
+#define ADL_SDK_MAJOR_VERSION 18
+#define ADL_SDK_MINOR_VERSION 0
 
 #endif /* ADL_SDK_H_ */

src/3rdparty/display-library/adl_structures.h

@@ -21,7 +21,7 @@
 // SOFTWARE.
 
 /// \file adl_structures.h
-///\brief This file contains the structure declarations that are used by the public ADL interfaces for \ALL platforms.\n <b>Included in ADL SDK</b>
+///\brief This file contains the structure declarations that are used by the public ADL interfaces for \WIN platforms.\n <b>Included in ADL SDK</b>
 ///
 /// All data structures used in AMD Display Library (ADL) public interfaces should be defined in this header file.
 ///
@@ -41,7 +41,7 @@
 ////////////////////////////////////////////////////////////////////////////////////////////
 typedef struct AdapterInfo
 {
-/// \ALL_STRUCT_MEM
+/// \WIN_STRUCT_MEM
 
 /// Size of the structure.
     int iSize;
@@ -59,7 +59,7 @@ typedef struct AdapterInfo
     int iVendorID;
 /// Adapter name.
     char strAdapterName[ADL_MAX_PATH];
-/// Display name. For example, "\\\\Display0" for Windows or ":0:0" for Linux.
+/// Display name. For example, "\\\\Display0" for Windows.
     char strDisplayName[ADL_MAX_PATH];
 /// Present or not; 1 if present and 0 if not present.It the logical adapter is present, the display name such as \\\\.\\Display1 can be found from OS
     int iPresent;
@@ -80,38 +80,8 @@ typedef struct AdapterInfo
 
 #endif /* (_WIN32) || (_WIN64) */
 
-#if defined (LINUX)
-/// \LNX_STRUCT_MEM
-
-/// Internal X screen number from GPUMapInfo (DEPRICATED use XScreenInfo)
-    int iXScreenNum;
-/// Internal driver index from GPUMapInfo
-    int iDrvIndex;
-/// \deprecated Internal x config file screen identifier name. Use XScreenInfo instead.
-    char strXScreenConfigName[ADL_MAX_PATH];
-
-#endif /* (LINUX) */
 } AdapterInfo, *LPAdapterInfo;
 
-/////////////////////////////////////////////////////////////////////////////////////////////
-///\brief Structure containing information about the Linux X screen information.
-///
-/// This structure is used to store the current screen number and xorg.conf ID name assoicated with an adapter index.
-/// This structure is updated during ADL_Main_Control_Refresh or ADL_ScreenInfo_Update.
-/// Note:  This structure should be used in place of iXScreenNum and strXScreenConfigName in AdapterInfo as they will be
-/// deprecated.
-/// \nosubgrouping
-////////////////////////////////////////////////////////////////////////////////////////////
-#if defined (LINUX)
-typedef struct XScreenInfo
-{
-/// Internal X screen number from GPUMapInfo.
-    int iXScreenNum;
-/// Internal x config file screen identifier name.
-    char strXScreenConfigName[ADL_MAX_PATH];
-} XScreenInfo, *LPXScreenInfo;
-#endif /* (LINUX) */
-
 /////////////////////////////////////////////////////////////////////////////////////////////
 ///\brief Structure containing information about an controller mode
 ///
@@ -453,8 +423,12 @@ typedef struct ADLDDCInfo2
     int ulMaxBacklightMinLuminanceData;
     int ulMinBacklightMinLuminanceData;
 
+    // Display screen width/height
+    int ulScreenWidth;
+    int ulScreenHeight;
+
     // Reserved for future use
-    int iReserved[4];
+    int iReserved[2];
 } ADLDDCInfo2, *LPADLDDCInfo2;
 
 /////////////////////////////////////////////////////////////////////////////////////////////
@@ -3614,6 +3588,23 @@ typedef struct ADL_BOOST_SETTINGS
 	int GlobalMinRes_Step; //Gloabl Min Resolution step  value
 }ADL_BOOST_SETTINGS;
 
+/////////////////////////////////////////////////////////////////////////////////////////////
+///\brief Structure containing information about BOOST Settings
+///
+///  Elements of BOOST settings.
+/// \nosubgrouping
+////////////////////////////////////////////////////////////////////////////////////////////
+typedef struct ADL_BOOST_SETTINGSX2
+{
+    int Hotkey; // Hotkey value
+    int GlobalEnable; //Global enable value
+    int GlobalMinRes; //Gloabl Min Resolution value
+    int GlobalMinRes_MinLimit; //Gloabl Min Resolution slider min limit value
+    int GlobalMinRes_MaxLimit; //Gloabl Min Resolution slider max limit value
+    int GlobalMinRes_Step; //Gloabl Min Resolution step  value
+    int VsrSupported; //Allows for interop with Upscaling/RSR
+}ADL_BOOST_SETTINGSX2;
+
 
 /////////////////////////////////////////////////////////////////////////////////////////////
 ///\brief Structure containing information about ProVSR Settings change reason
@@ -3817,7 +3808,7 @@ typedef struct ADL_RADEON_LED_PATTERN_CONFIG
 ////////////////////////////////////////////////////////////////////////////////////////////
 typedef struct AdapterInfoX2
 {
-    /// \ALL_STRUCT_MEM
+    /// \WIN_STRUCT_MEM
 
     /// Size of the structure.
     int iSize;
@@ -4164,6 +4155,7 @@ typedef struct ADLHDCPSettings
 ///
 /// This structure is used to store the Mantle Driver information
 /// \nosubgrouping
+/// \deprecated This structure has been deprecated.
 ////////////////////////////////////////////////////////////////////////////////////////////
 
 typedef struct ADLMantleAppInfo
@@ -4286,4 +4278,5 @@ typedef struct ADLSmartShiftSettings
 	int iCurrentValue;
     int iFlags; //refer to define_smartshift_bits
 }ADLSmartShiftSettings, *LPADLSmartShiftSettings;
-#endif /* ADL_STRUCTURES_H_ */
+
+#endif /* ADL_STRUCTURES_H_ */

src/3rdparty/display-library/repo.json

@@ -1,6 +1,6 @@
 {
     "home": "https://github.com/GPUOpen-LibrariesAndSDKs/display-library",
     "license": "MIT (embeded in source)",
-    "version": "ADL SDK 17.1",
+    "version": "ADL SDK 18.1",
     "author": "Advanced Micro Devices, Inc"
 }

src/common/FFPlatform.h

@@ -3,8 +3,7 @@
 #include "common/FFstrbuf.h"
 #include "common/FFlist.h"
 
-typedef struct FFPlatformSysinfo
-{
+typedef struct FFPlatformSysinfo {
     FFstrbuf name;
     FFstrbuf release;
     FFstrbuf version;
@@ -12,8 +11,7 @@ typedef struct FFPlatformSysinfo
     uint32_t pageSize;
 } FFPlatformSysinfo;
 
-typedef struct FFPlatform
-{
+typedef struct FFPlatform {
     FFstrbuf homeDir;  // Trailing slash included
     FFstrbuf cacheDir; // Trailing slash included
     FFlist configDirs; // List of FFstrbuf, trailing slash included
@@ -22,17 +20,21 @@ typedef struct FFPlatform
     FFstrbuf cwd;      // Trailing slash included
 
     uint32_t pid;
-    #ifndef _WIN32
+#ifndef _WIN32
     uint32_t uid;
-    #else
+#else
     FFstrbuf sid;
-    #endif
+#endif
     FFstrbuf userName;
     FFstrbuf fullUserName;
     FFstrbuf hostName;
     FFstrbuf userShell;
 
     FFPlatformSysinfo sysinfo;
+
+#if _WIN32
+    uint32_t initCP; // The code page used by the console when the program started
+#endif
 } FFPlatform;
 
 void ffPlatformInit(FFPlatform* platform);

src/common/FFcheckmacros.h

@@ -1,37 +0,0 @@
-#pragma once
-
-#ifdef _MSC_VER
-    #include <sal.h>
-#endif
-
-#if defined(__has_attribute) && __has_attribute(__warn_unused_result__)
-    #define FF_C_NODISCARD __attribute__((__warn_unused_result__))
-#elif defined(_MSC_VER)
-    #define FF_C_NODISCARD _Check_return_
-#else
-    #define FF_C_NODISCARD
-#endif
-
-#if defined(__has_attribute) && __has_attribute(__format__)
-    #define FF_C_PRINTF(formatStrIndex, argsStartIndex) __attribute__((__format__ (printf, formatStrIndex, argsStartIndex)))
-#else
-    #define FF_C_PRINTF(formatStrIndex, argsStartIndex)
-#endif
-
-#if defined(__has_attribute) && __has_attribute(__format__)
-    #define FF_C_SCANF(formatStrIndex, argsStartIndex) __attribute__((__format__ (scanf, formatStrIndex, argsStartIndex)))
-#else
-    #define FF_C_SCANF(formatStrIndex, argsStartIndex)
-#endif
-
-#if defined(__has_attribute) && __has_attribute(__nonnull__)
-    #define FF_C_NONNULL(argIndex, ...) __attribute__((__nonnull__(argIndex, ##__VA_ARGS__)))
-#else
-    #define FF_C_NONNULL(argIndex, ...)
-#endif
-
-#if defined(__has_attribute) && __has_attribute(__returns_nonnull__)
-    #define FF_C_RETURNS_NONNULL __attribute__((__returns_nonnull__))
-#else
-    #define FF_C_RETURNS_NONNULL
-#endif

src/common/FFlist.h

@@ -1,135 +1,166 @@
 #pragma once
 
-#include "FFcheckmacros.h"
-
 #include <stdbool.h>
 #include <stdint.h>
 #include <assert.h>
 #include <stdlib.h>
+#include <string.h>
 
 #define FF_LIST_DEFAULT_ALLOC 16
 
-typedef struct FFlist
-{
+typedef struct FFlist {
     uint8_t* data;
-    uint32_t elementSize;
     uint32_t length;
     uint32_t capacity;
 } FFlist;
 
-void* ffListAdd(FFlist* list);
-
 // Removes the first element, and copy its value to `*result`
-bool ffListShift(FFlist* list, void* result);
+bool ffListShift(FFlist* list, uint32_t elementSize, void* __restrict result);
 // Removes the last element, and copy its value to `*result`
-bool ffListPop(FFlist* list, void* result);
+bool ffListPop(FFlist* list, uint32_t elementSize, void* __restrict result);
 
-static inline void ffListInit(FFlist* list, uint32_t elementSize)
-{
-    assert(elementSize > 0);
-    list->elementSize = elementSize;
+static inline void ffListInit(FFlist* list) {
     list->capacity = 0;
     list->length = 0;
-    list->data = NULL;
+    list->data = nullptr;
 }
 
-static inline void ffListInitA(FFlist* list, uint32_t elementSize, uint32_t capacity)
-{
-    ffListInit(list, elementSize);
+static inline void ffListInitA(FFlist* list, uint32_t elementSize, uint32_t capacity) {
+    ffListInit(list);
     list->capacity = capacity;
-    list->data = __builtin_expect(capacity == 0, 0) ? NULL : (uint8_t*) malloc((size_t)list->capacity * list->elementSize);
+    list->data = __builtin_expect(capacity == 0, 0) ? nullptr : (uint8_t*) malloc((size_t) capacity * elementSize);
 }
 
-static inline FFlist ffListCreate(uint32_t elementSize)
-{
+[[nodiscard]] static inline FFlist ffListCreate() {
     FFlist result;
-    ffListInit(&result, elementSize);
+    ffListInit(&result);
     return result;
 }
 
-static inline void* ffListGet(const FFlist* list, uint32_t index)
-{
-    assert(list->capacity > index);
-    return list->data + (index * list->elementSize);
+[[nodiscard]] static inline FFlist ffListCreateA(uint32_t elementSize, uint32_t capacity) {
+    FFlist result;
+    ffListInitA(&result, elementSize, capacity);
+    return result;
 }
 
-FF_C_NODISCARD static inline uint32_t ffListFirstIndexComp(const FFlist* list, void* compElement, bool(*compFunc)(const void*, const void*))
-{
-    for(uint32_t i = 0; i < list->length; i++)
-    {
-        if(compFunc(ffListGet(list, i), compElement))
+[[nodiscard]] static inline void* ffListGet(const FFlist* list, uint32_t elementSize, uint32_t index) {
+    assert(list->capacity > index);
+    return list->data + (index * elementSize);
+}
+
+[[nodiscard]] static inline uint32_t ffListFirstIndexComp(const FFlist* list, uint32_t elementSize, void* compElement, bool (*compFunc)(const void*, const void*)) {
+    for (uint32_t i = 0; i < list->length; i++) {
+        if (compFunc(ffListGet(list, elementSize, i), compElement)) {
             return i;
+        }
     }
 
     return list->length;
 }
 
-static inline bool ffListContains(const FFlist* list, void* compElement, bool(*compFunc)(const void*, const void*))
-{
-    return ffListFirstIndexComp(list, compElement, compFunc) != list->length;
+[[nodiscard]] static inline bool ffListContains(const FFlist* list, uint32_t elementSize, void* compElement, bool (*compFunc)(const void*, const void*)) {
+    return ffListFirstIndexComp(list, elementSize, compElement, compFunc) != list->length;
 }
 
-static inline void ffListSort(FFlist* list, int(*compar)(const void*, const void*))
-{
-    qsort(list->data, list->length, list->elementSize, compar);
+static inline void ffListSort(FFlist* list, uint32_t elementSize, int (*compar)(const void*, const void*)) {
+    qsort(list->data, list->length, elementSize, compar);
 }
 
 // Move the contents of `src` into `list`, and left `src` empty
-static inline void ffListInitMove(FFlist* list, FFlist* src)
-{
-    if (src)
-    {
-        list->elementSize = src->elementSize;
+static inline void ffListInitMove(FFlist* list, FFlist* src) {
+    if (src) {
         list->capacity = src->capacity;
         list->length = src->length;
         list->data = src->data;
-        ffListInit(src, list->elementSize);
-    }
-    else
-    {
-        ffListInit(list, 0);
+        ffListInit(src);
+    } else {
+        ffListInit(list);
     }
 }
 
-static inline void ffListDestroy(FFlist* list)
-{
-    if (!list->data) return;
+static inline void ffListDestroy(FFlist* list) {
+    if (!list->data) {
+        return;
+    }
 
-    //Avoid free-after-use. These 3 assignments are cheap so don't remove them
+    // Avoid free-after-use. These 3 assignments are cheap so don't remove them
     list->capacity = list->length = 0;
     free(list->data);
-    list->data = NULL;
+    list->data = nullptr;
 }
 
-static inline void ffListClear(FFlist* list)
-{
+static inline void ffListClear(FFlist* list) {
     list->length = 0;
 }
 
-#define FF_LIST_FOR_EACH(itemType, itemVarName, listVar) \
-    assert(sizeof(itemType) == (listVar).elementSize); \
-    for(itemType* itemVarName = (itemType*)(listVar).data; \
-        itemVarName - (itemType*)(listVar).data < (intptr_t)(listVar).length; \
+static inline void ffListReserve(FFlist* list, uint32_t elementSize, uint32_t newCapacity) {
+    if (__builtin_expect(newCapacity <= list->capacity, false)) {
+        return;
+    }
+
+    list->data = (uint8_t*) realloc(list->data, (size_t) newCapacity * elementSize);
+    list->capacity = newCapacity;
+}
+
+static inline void* ffListAdd(FFlist* list, uint32_t elementSize) {
+    if (__builtin_expect(list->length == list->capacity, false)) {
+        ffListReserve(list, elementSize, list->capacity == 0 ? FF_LIST_DEFAULT_ALLOC : list->capacity * 2);
+    }
+
+    ++list->length;
+    return ffListGet(list, elementSize, list->length - 1);
+}
+
+static inline void ffListRemoveAt(FFlist* list, uint32_t elementSize, uint32_t index) {
+    assert(list->length > index);
+    memmove(list->data + (index * elementSize), list->data + ((index + 1) * elementSize), (size_t) (list->length - index - 1) * elementSize);
+    --list->length;
+}
+
+static inline void ffListInsertAt(FFlist* list, uint32_t elementSize, uint32_t index, const void* element) {
+    assert(list->length >= index);
+    ffListAdd(list, elementSize);
+    memmove(list->data + ((index + 1) * elementSize), list->data + (index * elementSize), (size_t) (list->length - index - 1) * elementSize);
+    memcpy(list->data + (index * elementSize), element, elementSize);
+}
+
+#define FF_LIST_FOR_EACH(itemType, itemVarName, listVar)                        \
+    for (itemType* itemVarName = (itemType*) (listVar).data;                    \
+        itemVarName - (itemType*) (listVar).data < (intptr_t) (listVar).length; \
         ++itemVarName)
 
-#define FF_LIST_AUTO_DESTROY FFlist __attribute__((__cleanup__(ffListDestroy)))
+#define FF_LIST_AUTO_DESTROY [[gnu::cleanup(ffListDestroy)]] FFlist
 
 #define FF_LIST_GET(itemType, listVar, index) \
-    ({ \
-        assert(sizeof(itemType) == (listVar).elementSize); \
+    ({                                        \
         assert((listVar).capacity > (index)); \
-        (itemType*)(listVar).data + (index); \
+        (itemType*) (listVar).data + (index); \
     })
 
-#define FF_LIST_ADD(itemType, listVar) \
-    ({ \
-        assert(sizeof(itemType) == (listVar).elementSize); \
-        (itemType*) ffListAdd(&(listVar)); \
-    })
+#define FF_LIST_ADD(itemType, listVar) (itemType*) ffListAdd(&(listVar), (uint32_t) sizeof(itemType))
+
+#define FF_LIST_REMOVE_AT(itemType, listVar, index) \
+    ffListRemoveAt(&(listVar), (uint32_t) sizeof(itemType), (index))
+
+#define FF_LIST_INSERT_AT(itemType, listVar, index, pElement) \
+    ffListInsertAt(&(listVar), (uint32_t) sizeof(itemType), (index), (pElement))
 
 #define FF_LIST_FIRST(itemType, listVar) FF_LIST_GET(itemType, listVar, 0)
-#define FF_LIST_LAST(itemType, listVar) \
-    ({ \
-        assert((listVar).length > 0); \
+#define FF_LIST_LAST(itemType, listVar)                         \
+    ({                                                          \
+        assert((listVar).length > 0);                           \
         FF_LIST_GET(itemType, listVar, ((listVar).length - 1)); \
     })
+
+#define FF_LIST_CONTAINS(listVar, pCompElement, compFunc)                                                                              \
+    ({                                                                                                                                 \
+        typedef typeof(*(pCompElement)) compElementType;                                                                               \
+        typedef bool compFuncType(const compElementType*, const compElementType*);                                                     \
+        static_assert(__builtin_types_compatible_p(typeof(compFunc), compFuncType), "Incompatible callback function");                 \
+        ffListContains(&(listVar), (uint32_t) sizeof(*(pCompElement)), (pCompElement), (bool (*)(const void*, const void*)) compFunc); \
+    })
+
+#define FF_LIST_SHIFT(listVar, pResult) \
+    ffListShift(&(listVar), (uint32_t) sizeof(*(pResult)), (pResult))
+#define FF_LIST_POP(listVar, pResult) \
+    ffListPop(&(listVar), (uint32_t) sizeof(*(pResult)), (pResult))

src/common/FFstrbuf.h

@@ -1,7 +1,5 @@
 #pragma once
 
-#include "FFcheckmacros.h"
-
 #include <stdint.h>
 #include <stdarg.h>
 #include <stdbool.h>
@@ -9,6 +7,8 @@
 #include <string.h>
 #include <stdlib.h>
 #include <assert.h>
+#include "common/memrchr.h"
+#include "common/arrutil.h"
 
 #ifdef FF_USE_SYSTEM_YYJSON
     #include <yyjson.h>
@@ -17,8 +17,8 @@
 #endif
 
 #ifdef _WIN32
-    // #include <shlwapi.h>
-    __stdcall char* StrStrIA(const char* lpFirst, const char* lpSrch);
+// #include <shlwapi.h>
+__stdcall char* StrStrIA(const char* lpFirst, const char* lpSrch);
     #define strcasestr StrStrIA
 #endif
 
@@ -26,8 +26,7 @@
 
 // static string (allocated == 0), chars points to a string literal
 // dynamic string (allocated > 0), chars points to a heap allocated buffer
-typedef struct FFstrbuf
-{
+typedef struct FFstrbuf {
     uint32_t allocated;
     uint32_t length;
     char* chars;
@@ -37,18 +36,15 @@ static inline void ffStrbufInit(FFstrbuf* strbuf);
 void ffStrbufInitA(FFstrbuf* strbuf, uint32_t allocate);
 void ffStrbufInitVF(FFstrbuf* strbuf, const char* format, va_list arguments);
 void ffStrbufInitMoveNS(FFstrbuf* strbuf, uint32_t length, char* heapStr);
+[[gnu::format(printf, 2, 3)]] void ffStrbufInitF(FFstrbuf* strbuf, const char* format, ...);
+[[gnu::format(printf, 1, 2)]] [[nodiscard]] FFstrbuf ffStrbufCreateF(const char* format, ...);
 
-void ffStrbufEnsureFree(FFstrbuf* strbuf, uint32_t free);
 void ffStrbufEnsureFixedLengthFree(FFstrbuf* strbuf, uint32_t free);
-
-void ffStrbufClear(FFstrbuf* strbuf);
+void ffStrbufEnsureFreeNoCheck(FFstrbuf* strbuf, uint32_t free);
 
 static inline void ffStrbufAppend(FFstrbuf* __restrict strbuf, const FFstrbuf* __restrict value);
-void ffStrbufAppendC(FFstrbuf* strbuf, char c);
-void ffStrbufAppendNC(FFstrbuf* strbuf, uint32_t num, char c);
-void ffStrbufAppendNS(FFstrbuf* strbuf, uint32_t length, const char* value);
-void ffStrbufAppendTransformS(FFstrbuf* strbuf, const char* value, int(*transformFunc)(int));
-FF_C_PRINTF(2, 3) void ffStrbufAppendF(FFstrbuf* strbuf, const char* format, ...);
+void ffStrbufAppendTransformS(FFstrbuf* strbuf, const char* value, int (*transformFunc)(int));
+[[gnu::format(printf, 2, 3)]] void ffStrbufAppendF(FFstrbuf* strbuf, const char* format, ...);
 void ffStrbufAppendVF(FFstrbuf* strbuf, const char* format, va_list arguments);
 const char* ffStrbufAppendSUntilC(FFstrbuf* strbuf, const char* value, char until);
 
@@ -61,7 +57,7 @@ void ffStrbufInsertNC(FFstrbuf* strbuf, uint32_t index, uint32_t num, char c);
 // NOTE: Unlike ffStrbufAppend*, ffStrbufSet* functions may NOT reserve extra space
 void ffStrbufSet(FFstrbuf* strbuf, const FFstrbuf* value);
 void ffStrbufSetNS(FFstrbuf* strbuf, uint32_t length, const char* value);
-FF_C_PRINTF(2, 3) void ffStrbufSetF(FFstrbuf* strbuf, const char* format, ...);
+[[gnu::format(printf, 2, 3)]] void ffStrbufSetF(FFstrbuf* strbuf, const char* format, ...);
 
 void ffStrbufTrimLeft(FFstrbuf* strbuf, char c);
 void ffStrbufTrimRight(FFstrbuf* strbuf, char c);
@@ -72,11 +68,6 @@ bool ffStrbufRemoveSubstr(FFstrbuf* strbuf, uint32_t startIndex, uint32_t endInd
 void ffStrbufRemoveS(FFstrbuf* strbuf, const char* str);
 void ffStrbufRemoveStrings(FFstrbuf* strbuf, uint32_t numStrings, const char* strings[]);
 
-FF_C_NODISCARD uint32_t ffStrbufNextIndexC(const FFstrbuf* strbuf, uint32_t start, char c);
-FF_C_NODISCARD uint32_t ffStrbufNextIndexS(const FFstrbuf* strbuf, uint32_t start, const char* str);
-
-FF_C_NODISCARD uint32_t ffStrbufPreviousIndexC(const FFstrbuf* strbuf, uint32_t start, char c);
-
 void ffStrbufReplaceAllC(FFstrbuf* strbuf, char find, char replace);
 
 // Returns true if the strbuf is modified
@@ -87,25 +78,18 @@ bool ffStrbufSubstrAfterFirstS(FFstrbuf* strbuf, const char* str);
 bool ffStrbufSubstrAfterLastC(FFstrbuf* strbuf, char c);
 bool ffStrbufSubstr(FFstrbuf* strbuf, uint32_t start, uint32_t end);
 
-FF_C_NODISCARD uint32_t ffStrbufCountC(const FFstrbuf* strbuf, char c);
+[[nodiscard]] uint32_t ffStrbufCountC(const FFstrbuf* strbuf, char c);
 
 bool ffStrbufRemoveIgnCaseEndS(FFstrbuf* strbuf, const char* end);
 
 bool ffStrbufEnsureEndsWithC(FFstrbuf* strbuf, char c);
 
-void ffStrbufWriteTo(const FFstrbuf* strbuf, FILE* file);
-void ffStrbufPutTo(const FFstrbuf* strbuf, FILE* file);
-
-FF_C_NODISCARD double ffStrbufToDouble(const FFstrbuf* strbuf, double defaultValue);
-FF_C_NODISCARD int64_t ffStrbufToSInt(const FFstrbuf* strbuf, int64_t defaultValue);
-FF_C_NODISCARD uint64_t ffStrbufToUInt(const FFstrbuf* strbuf, uint64_t defaultValue);
-
 void ffStrbufUpperCase(FFstrbuf* strbuf);
 void ffStrbufLowerCase(FFstrbuf* strbuf);
 
 // Function alters the buffer to extract lines or delimited segments (replaces the delimiter with '\0')
 // so that buffer MUST be heap allocated (NOT a static string)
-// `lineptr` must be `NULL` and `n` MUST be `0` for the first call
+// `lineptr` must be `nullptr` and `n` MUST be `0` for the first call
 // Caller MUST NOT free `*lineptr`
 bool ffStrbufGetdelim(char** lineptr, size_t* n, char delimiter, FFstrbuf* buffer);
 void ffStrbufGetdelimRestore(char** lineptr, size_t* n, char delimiter, FFstrbuf* buffer);
@@ -118,7 +102,7 @@ void ffStrbufGetdelimRestore(char** lineptr, size_t* n, char delimiter, FFstrbuf
  * @param[in,out] lineptr The pointer to a pointer that will be set to the start of the line
                           (points to buffer's internal memory address to avoid memory allocation and copy).
                           MUST NOT be freed by the caller, unlike `getline(3)`.
- *                        MUST be NULL for the first call.
+ *                        MUST be nullptr for the first call.
  * @param[in,out] n The pointer to the size of the buffer of lineptr.
                     MUST be 0 for the first call.
  * @param[in] buffer The buffer to read from.
@@ -126,16 +110,14 @@ void ffStrbufGetdelimRestore(char** lineptr, size_t* n, char delimiter, FFstrbuf
  *
  * @return true if a line has been read, false if the end of the buffer has been reached.
  */
-static inline bool ffStrbufGetline(char** lineptr, size_t* n, FFstrbuf* buffer)
-{
+static inline bool ffStrbufGetline(char** lineptr, size_t* n, FFstrbuf* buffer) {
     return ffStrbufGetdelim(lineptr, n, '\n', buffer);
 }
 /**
  * @brief Restore the end of a line that was modified by ffStrbufGetline.
  * @warning This function should be called before breaking an ffStrbufGetline loop if `buffer` will be used later.
  */
-static inline void ffStrbufGetlineRestore(char** lineptr, size_t* n, FFstrbuf* buffer)
-{
+static inline void ffStrbufGetlineRestore(char** lineptr, size_t* n, FFstrbuf* buffer) {
     ffStrbufGetdelimRestore(lineptr, n, '\n', buffer);
 }
 bool ffStrbufRemoveDupWhitespaces(FFstrbuf* strbuf);
@@ -152,122 +134,147 @@ void ffStrbufAppendUInt(FFstrbuf* strbuf, uint64_t value);
 // if `precision < 0`, let yyjson decide the precision
 void ffStrbufAppendDouble(FFstrbuf* strbuf, double value, int8_t precision, bool trailingZeros);
 
-FF_C_NODISCARD static inline FFstrbuf ffStrbufCreateA(uint32_t allocate)
-{
+[[nodiscard]] static inline FFstrbuf ffStrbufCreateA(uint32_t allocate) {
     FFstrbuf strbuf;
     ffStrbufInitA(&strbuf, allocate);
     return strbuf;
 }
 
-static inline void ffStrbufInitCopy(FFstrbuf* __restrict strbuf, const FFstrbuf* __restrict src)
-{
-    if (src->allocated == 0) // static string
+static inline void ffStrbufInitCopy(FFstrbuf* __restrict strbuf, const FFstrbuf* __restrict src) {
+    if (src->allocated == 0) { // static string
         *strbuf = *src;
-    else
-    {
+    } else {
         ffStrbufInitA(strbuf, src->allocated);
         ffStrbufAppend(strbuf, src);
     }
 }
 
-FF_C_NODISCARD static inline FFstrbuf ffStrbufCreateCopy(const FFstrbuf* src)
-{
+[[nodiscard]] static inline FFstrbuf ffStrbufCreateCopy(const FFstrbuf* src) {
     FFstrbuf strbuf;
     ffStrbufInitCopy(&strbuf, src);
     return strbuf;
 }
 
 // Move the content of `src` into `strbuf`, and left `src` empty
-static inline void ffStrbufInitMove(FFstrbuf* strbuf, FFstrbuf* src)
-{
-    if (src)
-    {
+static inline void ffStrbufInitMove(FFstrbuf* strbuf, FFstrbuf* src) {
+    if (src) {
         *strbuf = *src;
         ffStrbufInit(src);
-    }
-    else
+    } else {
         ffStrbufInit(strbuf);
+    }
 }
 
-FF_C_NODISCARD static inline FFstrbuf ffStrbufCreateMove(FFstrbuf* src)
-{
+[[nodiscard]] static inline FFstrbuf ffStrbufCreateMove(FFstrbuf* src) {
     FFstrbuf strbuf;
     ffStrbufInitMove(&strbuf, src);
     return strbuf;
 }
 
-FF_C_NODISCARD static inline FFstrbuf ffStrbufCreateVF(const char* format, va_list arguments)
-{
-    FFstrbuf strbuf;
-    ffStrbufInitVF(&strbuf, format, arguments);
-    return strbuf;
-}
-
-FF_C_PRINTF(2, 3)
-static inline void ffStrbufInitF(FFstrbuf* strbuf, const char* format, ...)
-{
-    va_list arguments;
-    va_start(arguments, format);
-    ffStrbufInitVF(strbuf, format, arguments);
-    va_end(arguments);
-}
-
-FF_C_PRINTF(1, 2)
-FF_C_NODISCARD static inline FFstrbuf ffStrbufCreateF(const char* format, ...)
-{
-    FFstrbuf strbuf;
-
-    va_list arguments;
-    va_start(arguments, format);
-    ffStrbufInitVF(&strbuf, format, arguments);
-    va_end(arguments);
-
-    return strbuf;
-}
-
-static inline void ffStrbufInitMoveS(FFstrbuf* strbuf, char* heapStr)
-{
+static inline void ffStrbufInitMoveS(FFstrbuf* strbuf, char* heapStr) {
     ffStrbufInitMoveNS(strbuf, (uint32_t) strlen(heapStr), heapStr);
 }
 
-static inline void ffStrbufDestroy(FFstrbuf* strbuf)
-{
-    if(strbuf->allocated > 0)
+// Despite the name, this function resets strbuf to the initial/unallocated state
+static inline void ffStrbufDestroy(FFstrbuf* strbuf) {
+    if (strbuf->allocated > 0) {
         free(strbuf->chars);
+    }
 
     ffStrbufInit(strbuf);
 }
 
-FF_C_NODISCARD static inline uint32_t ffStrbufGetFree(const FFstrbuf* strbuf)
-{
-    assert(strbuf != NULL);
-    if(strbuf->allocated == 0)
+[[nodiscard]] static inline uint32_t ffStrbufGetFree(const FFstrbuf* strbuf) {
+    assert(strbuf != nullptr);
+    if (strbuf->allocated == 0) {
         return 0;
+    }
 
     return strbuf->allocated - strbuf->length - 1; // - 1 for the null byte
 }
 
-static inline void ffStrbufRecalculateLength(FFstrbuf* strbuf)
-{
+static inline void ffStrbufEnsureFree(FFstrbuf* strbuf, uint32_t free) {
+    if (__builtin_expect(free == 0, false)) {
+        if (__builtin_expect(!(strbuf->allocated == 0 && strbuf->length > 0), true)) {
+            return;
+        }
+    } else {
+        if (__builtin_expect(ffStrbufGetFree(strbuf) >= free, true)) {
+            return;
+        }
+    }
+
+    ffStrbufEnsureFreeNoCheck(strbuf, free);
+}
+
+
+static inline void ffStrbufClear(FFstrbuf* strbuf) {
+    assert(strbuf != nullptr);
+    extern char* CHAR_NULL_PTR;
+
+    if (strbuf->allocated == 0) {
+        strbuf->chars = CHAR_NULL_PTR;
+    } else {
+        strbuf->chars[0] = '\0';
+    }
+
+    strbuf->length = 0;
+}
+
+static inline void ffStrbufAppendC(FFstrbuf* strbuf, char c) {
+    ffStrbufEnsureFree(strbuf, 1);
+    strbuf->chars[strbuf->length++] = c;
+    strbuf->chars[strbuf->length] = '\0';
+}
+
+static inline void ffStrbufAppendNC(FFstrbuf* strbuf, uint32_t num, char c) {
+    if (__builtin_expect(num == 0, false)) {
+        return;
+    }
+    ffStrbufEnsureFree(strbuf, num);
+
+    memset(&strbuf->chars[strbuf->length], c, num);
+    strbuf->length += num;
+    strbuf->chars[strbuf->length] = '\0';
+}
+
+static inline void ffStrbufAppendNS(FFstrbuf* strbuf, uint32_t length, const char* value) {
+    if (__builtin_expect(value == nullptr || length == 0, false)) {
+        return;
+    }
+    ffStrbufEnsureFree(strbuf, length);
+
+    memcpy(&strbuf->chars[strbuf->length], value, length);
+    strbuf->length += length;
+    strbuf->chars[strbuf->length] = '\0';
+}
+
+static inline void ffStrbufAppend(FFstrbuf* __restrict strbuf, const FFstrbuf* __restrict value) {
+    assert(value != strbuf);
+    if (value == nullptr) {
+        return;
+    }
+    ffStrbufAppendNS(strbuf, value->length, value->chars);
+}
+
+static inline void ffStrbufRecalculateLength(FFstrbuf* strbuf) {
     strbuf->length = (uint32_t) strlen(strbuf->chars);
 }
 
-static inline void ffStrbufSetS(FFstrbuf* strbuf, const char* value)
-{
-    assert(strbuf != NULL);
+static inline void ffStrbufSetS(FFstrbuf* strbuf, const char* value) {
+    assert(strbuf != nullptr);
 
-    if (value == NULL)
+    if (value == nullptr) {
         ffStrbufClear(strbuf);
-    else
+    } else {
         ffStrbufSetNS(strbuf, (uint32_t) strlen(value), value);
+    }
 }
 
-static inline bool ffStrbufSetJsonVal(FFstrbuf* strbuf, yyjson_val* jsonVal)
-{
-    assert(strbuf != NULL);
+static inline bool ffStrbufSetJsonVal(FFstrbuf* strbuf, yyjson_val* jsonVal) {
+    assert(strbuf != nullptr);
 
-    if (yyjson_is_str(jsonVal))
-    {
+    if (yyjson_is_str(jsonVal)) {
         ffStrbufSetNS(strbuf, (uint32_t) unsafe_yyjson_get_len(jsonVal), unsafe_yyjson_get_str(jsonVal));
         return true;
     }
@@ -276,355 +283,350 @@ static inline bool ffStrbufSetJsonVal(FFstrbuf* strbuf, yyjson_val* jsonVal)
     return false;
 }
 
-static inline void ffStrbufAppendS(FFstrbuf* strbuf, const char* value)
-{
-    if(value == NULL)
+static inline void ffStrbufAppendS(FFstrbuf* strbuf, const char* value) {
+    if (value == nullptr) {
         return;
+    }
     ffStrbufAppendNS(strbuf, (uint32_t) strlen(value), value);
 }
 
-static inline bool ffStrbufAppendJsonVal(FFstrbuf* strbuf, yyjson_val* jsonVal)
-{
-    if (yyjson_is_str(jsonVal))
-    {
+static inline bool ffStrbufAppendJsonVal(FFstrbuf* strbuf, yyjson_val* jsonVal) {
+    if (yyjson_is_str(jsonVal)) {
         ffStrbufAppendNS(strbuf, (uint32_t) unsafe_yyjson_get_len(jsonVal), unsafe_yyjson_get_str(jsonVal));
         return true;
     }
     return false;
 }
 
-static inline void ffStrbufInit(FFstrbuf* strbuf)
-{
+static inline void ffStrbufInit(FFstrbuf* strbuf) {
     extern char* CHAR_NULL_PTR;
     strbuf->allocated = strbuf->length = 0;
     strbuf->chars = CHAR_NULL_PTR;
 }
 
-FF_C_NODISCARD static inline FFstrbuf ffStrbufCreate(void)
-{
+[[nodiscard]] static inline FFstrbuf ffStrbufCreate(void) {
     FFstrbuf strbuf;
     ffStrbufInit(&strbuf);
     return strbuf;
 }
 
-static inline void ffStrbufInitStatic(FFstrbuf* strbuf, const char* str)
-{
+static inline void ffStrbufInitStatic(FFstrbuf* strbuf, const char* str) {
     ffStrbufInit(strbuf);
-    if (!str) return;
+    if (!str) {
+        return;
+    }
 
     strbuf->allocated = 0;
     strbuf->length = (uint32_t) strlen(str);
     strbuf->chars = (char*) str;
 }
 
-FF_C_NODISCARD static inline FFstrbuf ffStrbufCreateStatic(const char* str)
-{
+[[nodiscard]] static inline FFstrbuf ffStrbufCreateStatic(const char* str) {
     FFstrbuf strbuf;
     ffStrbufInitStatic(&strbuf, str);
     return strbuf;
 }
 
-static inline void ffStrbufSetStatic(FFstrbuf* strbuf, const char* value)
-{
-    if(strbuf->allocated > 0)
+static inline void ffStrbufSetStatic(FFstrbuf* strbuf, const char* value) {
+    if (strbuf->allocated > 0) {
         free(strbuf->chars);
+    }
 
-    if(value != NULL)
+    if (value != nullptr) {
         ffStrbufInitStatic(strbuf, value);
-    else
+    } else {
         ffStrbufInit(strbuf);
+    }
 }
 
-static inline void ffStrbufInitNS(FFstrbuf* strbuf, uint32_t length, const char* str)
-{
+static inline void ffStrbufInitNS(FFstrbuf* strbuf, uint32_t length, const char* str) {
     ffStrbufInit(strbuf);
     ffStrbufAppendNS(strbuf, length, str);
 }
 
-FF_C_NODISCARD static inline FFstrbuf ffStrbufCreateNS(uint32_t length, const char* str)
-{
+[[nodiscard]] static inline FFstrbuf ffStrbufCreateNS(uint32_t length, const char* str) {
     FFstrbuf strbuf;
     ffStrbufInitNS(&strbuf, length, str);
     return strbuf;
 }
 
-static inline bool ffStrbufInitJsonVal(FFstrbuf* strbuf, yyjson_val* jsonVal)
-{
+static inline bool ffStrbufInitJsonVal(FFstrbuf* strbuf, yyjson_val* jsonVal) {
     ffStrbufInit(strbuf);
     return ffStrbufAppendJsonVal(strbuf, jsonVal);
 }
 
-static inline void ffStrbufInitS(FFstrbuf* strbuf, const char* str)
-{
+static inline void ffStrbufInitS(FFstrbuf* strbuf, const char* str) {
     ffStrbufInit(strbuf);
     ffStrbufAppendS(strbuf, str);
 }
 
-FF_C_NODISCARD static inline FFstrbuf ffStrbufCreateS(const char* str)
-{
+[[nodiscard]] static inline FFstrbuf ffStrbufCreateS(const char* str) {
     FFstrbuf strbuf;
     ffStrbufInitS(&strbuf, str);
     return strbuf;
 }
 
-static inline void ffStrbufAppend(FFstrbuf* __restrict strbuf, const FFstrbuf* __restrict value)
-{
-    assert(value != strbuf);
-    if(value == NULL)
-        return;
-    ffStrbufAppendNS(strbuf, value->length, value->chars);
-}
-
-static inline void ffStrbufPrepend(FFstrbuf* strbuf, FFstrbuf* value)
-{
-    if(value == NULL)
+static inline void ffStrbufPrepend(FFstrbuf* strbuf, FFstrbuf* value) {
+    if (value == nullptr) {
         return;
+    }
     ffStrbufPrependNS(strbuf, value->length, value->chars);
 }
 
-static inline void ffStrbufPrependS(FFstrbuf* strbuf, const char* value)
-{
-    if(value == NULL)
+static inline void ffStrbufPrependS(FFstrbuf* strbuf, const char* value) {
+    if (value == nullptr) {
         return;
+    }
     ffStrbufPrependNS(strbuf, (uint32_t) strlen(value), value);
 }
 
-static inline FF_C_NODISCARD int ffStrbufComp(const FFstrbuf* strbuf, const FFstrbuf* comp)
-{
+[[nodiscard]] static inline int ffStrbufComp(const FFstrbuf* strbuf, const FFstrbuf* comp) {
     uint32_t length = strbuf->length > comp->length ? comp->length : strbuf->length;
     return memcmp(strbuf->chars, comp->chars, length + 1);
 }
 
-static inline FF_C_NODISCARD bool ffStrbufEqual(const FFstrbuf* strbuf, const FFstrbuf* comp)
-{
+[[nodiscard]] static inline bool ffStrbufEqual(const FFstrbuf* strbuf, const FFstrbuf* comp) {
     return ffStrbufComp(strbuf, comp) == 0;
 }
 
-static inline FF_C_NODISCARD int ffStrbufCompS(const FFstrbuf* strbuf, const char* comp)
-{
+[[nodiscard]] static inline int ffStrbufCompS(const FFstrbuf* strbuf, const char* comp) {
     return strcmp(strbuf->chars, comp);
 }
 
-static inline FF_C_NODISCARD bool ffStrbufEqualS(const FFstrbuf* strbuf, const char* comp)
-{
+[[nodiscard]] static inline bool ffStrbufEqualS(const FFstrbuf* strbuf, const char* comp) {
     return ffStrbufCompS(strbuf, comp) == 0;
 }
 
-static inline FF_C_NODISCARD int ffStrbufIgnCaseCompS(const FFstrbuf* strbuf, const char* comp)
-{
+[[nodiscard]] static inline int ffStrbufIgnCaseCompS(const FFstrbuf* strbuf, const char* comp) {
     return strcasecmp(strbuf->chars, comp);
 }
 
-static inline FF_C_NODISCARD bool ffStrbufIgnCaseEqualS(const FFstrbuf* strbuf, const char* comp)
-{
+[[nodiscard]] static inline bool ffStrbufIgnCaseEqualS(const FFstrbuf* strbuf, const char* comp) {
     return ffStrbufIgnCaseCompS(strbuf, comp) == 0;
 }
 
-static inline FF_C_NODISCARD int ffStrbufIgnCaseComp(const FFstrbuf* strbuf, const FFstrbuf* comp)
-{
+[[nodiscard]] static inline int ffStrbufIgnCaseComp(const FFstrbuf* strbuf, const FFstrbuf* comp) {
     return ffStrbufIgnCaseCompS(strbuf, comp->chars);
 }
 
-static inline FF_C_NODISCARD bool ffStrbufIgnCaseEqual(const FFstrbuf* strbuf, const FFstrbuf* comp)
-{
+[[nodiscard]] static inline bool ffStrbufIgnCaseEqual(const FFstrbuf* strbuf, const FFstrbuf* comp) {
     return ffStrbufIgnCaseComp(strbuf, comp) == 0;
 }
 
-static inline FF_C_NODISCARD bool ffStrbufContainC(const FFstrbuf* strbuf, char c)
-{
-    return memchr(strbuf->chars, c, strbuf->length) != NULL;
+[[nodiscard]] static inline bool ffStrbufContainC(const FFstrbuf* strbuf, char c) {
+    return memchr(strbuf->chars, c, strbuf->length) != nullptr;
 }
 
-static inline FF_C_NODISCARD bool ffStrbufContainS(const FFstrbuf* strbuf, const char* str)
-{
-    return strstr(strbuf->chars, str) != NULL;
+[[nodiscard]] static inline bool ffStrbufContainS(const FFstrbuf* strbuf, const char* str) {
+    return strstr(strbuf->chars, str) != nullptr;
 }
 
-static inline FF_C_NODISCARD bool ffStrbufContain(const FFstrbuf* strbuf, const FFstrbuf* str)
-{
+[[nodiscard]] static inline bool ffStrbufContain(const FFstrbuf* strbuf, const FFstrbuf* str) {
     return ffStrbufContainS(strbuf, str->chars);
 }
 
-static inline FF_C_NODISCARD bool ffStrbufContainIgnCaseS(const FFstrbuf* strbuf, const char* str)
-{
-    return strcasestr(strbuf->chars, str) != NULL;
+[[nodiscard]] static inline bool ffStrbufContainIgnCaseS(const FFstrbuf* strbuf, const char* str) {
+    return strcasestr(strbuf->chars, str) != nullptr;
 }
 
-static inline FF_C_NODISCARD bool ffStrbufContainIgnCase(const FFstrbuf* strbuf, const FFstrbuf* str)
-{
+[[nodiscard]] static inline bool ffStrbufContainIgnCase(const FFstrbuf* strbuf, const FFstrbuf* str) {
     return ffStrbufContainIgnCaseS(strbuf, str->chars);
 }
 
-static inline FF_C_NODISCARD uint32_t ffStrbufFirstIndexC(const FFstrbuf* strbuf, char c)
-{
+[[nodiscard]] static inline uint32_t ffStrbufNextIndexC(const FFstrbuf* strbuf, uint32_t start, char c) {
+    assert(start <= strbuf->length);
+
+    const char* ptr = (const char*) memchr(strbuf->chars + start, c, strbuf->length - start);
+    return ptr ? (uint32_t) (ptr - strbuf->chars) : strbuf->length;
+}
+
+[[nodiscard]] static inline uint32_t ffStrbufNextIndexS(const FFstrbuf* strbuf, uint32_t start, const char* str) {
+    assert(start <= strbuf->length);
+
+    const char* ptr = strstr(strbuf->chars + start, str);
+    return ptr ? (uint32_t) (ptr - strbuf->chars) : strbuf->length;
+}
+
+[[nodiscard]] static inline uint32_t ffStrbufPreviousIndexC(const FFstrbuf* strbuf, uint32_t start, char c) {
+    assert(start <= strbuf->length);
+
+    const char* ptr = (const char*) memrchr(strbuf->chars, c, start + 1);
+    return ptr ? (uint32_t) (ptr - strbuf->chars) : strbuf->length;
+}
+
+[[nodiscard]] static inline uint32_t ffStrbufFirstIndexC(const FFstrbuf* strbuf, char c) {
     return ffStrbufNextIndexC(strbuf, 0, c);
 }
 
-static inline FF_C_NODISCARD uint32_t ffStrbufFirstIndex(const FFstrbuf* strbuf, const FFstrbuf* searched)
-{
+[[nodiscard]] static inline uint32_t ffStrbufFirstIndex(const FFstrbuf* strbuf, const FFstrbuf* searched) {
     return ffStrbufNextIndexS(strbuf, 0, searched->chars);
 }
 
-static inline FF_C_NODISCARD uint32_t ffStrbufFirstIndexS(const FFstrbuf* strbuf, const char* str)
-{
+[[nodiscard]] static inline uint32_t ffStrbufFirstIndexS(const FFstrbuf* strbuf, const char* str) {
     return ffStrbufNextIndexS(strbuf, 0, str);
 }
 
-static inline FF_C_NODISCARD uint32_t ffStrbufLastIndexC(const FFstrbuf* strbuf, char c)
-{
-    if(strbuf->length == 0)
+[[nodiscard]] static inline uint32_t ffStrbufLastIndexC(const FFstrbuf* strbuf, char c) {
+    if (strbuf->length == 0) {
         return 0;
+    }
 
     return ffStrbufPreviousIndexC(strbuf, strbuf->length - 1, c);
 }
 
-static inline bool ffStrbufSubstrBeforeFirstC(FFstrbuf* strbuf, char c)
-{
+static inline bool ffStrbufSubstrBeforeFirstC(FFstrbuf* strbuf, char c) {
     return ffStrbufSubstrBefore(strbuf, ffStrbufFirstIndexC(strbuf, c));
 }
 
-static inline bool ffStrbufSubstrBeforeLastC(FFstrbuf* strbuf, char c)
-{
+static inline bool ffStrbufSubstrBeforeLastC(FFstrbuf* strbuf, char c) {
     return ffStrbufSubstrBefore(strbuf, ffStrbufLastIndexC(strbuf, c));
 }
 
-static inline FF_C_NODISCARD bool ffStrbufStartsWithC(const FFstrbuf* strbuf, char c)
-{
+[[nodiscard]] static inline bool ffStrbufStartsWithC(const FFstrbuf* strbuf, char c) {
     return strbuf->chars[0] == c;
 }
 
-static inline FF_C_NODISCARD bool ffStrbufStartsWithSN(const FFstrbuf* strbuf, const char* start, uint32_t length)
-{
-    if (length > strbuf->length)
+[[nodiscard]] static inline bool ffStrbufStartsWithSN(const FFstrbuf* strbuf, const char* start, uint32_t length) {
+    if (length > strbuf->length) {
         return false;
+    }
 
     return memcmp(strbuf->chars, start, length) == 0;
 }
 
-static inline FF_C_NODISCARD bool ffStrbufStartsWithS(const FFstrbuf* strbuf, const char* start)
-{
+[[nodiscard]] static inline bool ffStrbufStartsWithS(const FFstrbuf* strbuf, const char* start) {
     return ffStrbufStartsWithSN(strbuf, start, (uint32_t) strlen(start));
 }
 
-static inline FF_C_NODISCARD bool ffStrbufStartsWith(const FFstrbuf* strbuf, const FFstrbuf* start)
-{
+[[nodiscard]] static inline bool ffStrbufStartsWith(const FFstrbuf* strbuf, const FFstrbuf* start) {
     return ffStrbufStartsWithSN(strbuf, start->chars, start->length);
 }
 
-static inline FF_C_NODISCARD bool ffStrbufStartsWithIgnCaseNS(const FFstrbuf* strbuf, uint32_t length, const char* start)
-{
-    if(length > strbuf->length)
+[[nodiscard]] static inline bool ffStrbufStartsWithIgnCaseNS(const FFstrbuf* strbuf, uint32_t length, const char* start) {
+    if (length > strbuf->length) {
         return false;
+    }
     return strncasecmp(strbuf->chars, start, length) == 0;
 }
 
-static inline FF_C_NODISCARD bool ffStrbufStartsWithIgnCaseS(const FFstrbuf* strbuf, const char* start)
-{
+[[nodiscard]] static inline bool ffStrbufStartsWithIgnCaseS(const FFstrbuf* strbuf, const char* start) {
     return ffStrbufStartsWithIgnCaseNS(strbuf, (uint32_t) strlen(start), start);
 }
 
-static inline FF_C_NODISCARD bool ffStrbufStartsWithIgnCase(const FFstrbuf* strbuf, const FFstrbuf* start)
-{
+[[nodiscard]] static inline bool ffStrbufStartsWithIgnCase(const FFstrbuf* strbuf, const FFstrbuf* start) {
     return ffStrbufStartsWithIgnCaseNS(strbuf, start->length, start->chars);
 }
 
-static inline FF_C_NODISCARD bool ffStrbufEndsWithC(const FFstrbuf* strbuf, char c)
-{
-    return strbuf->length == 0 ? false :
-        strbuf->chars[strbuf->length - 1] == c;
+[[nodiscard]] static inline bool ffStrbufEndsWithC(const FFstrbuf* strbuf, char c) {
+    return strbuf->length == 0 ? false : strbuf->chars[strbuf->length - 1] == c;
 }
 
-static inline FF_C_NODISCARD bool ffStrbufEndsWithNS(const FFstrbuf* strbuf, uint32_t endLength, const char* end)
-{
-    if(endLength > strbuf->length)
+[[nodiscard]] static inline bool ffStrbufEndsWithNS(const FFstrbuf* strbuf, uint32_t endLength, const char* end) {
+    if (endLength > strbuf->length) {
         return false;
+    }
 
     return memcmp(strbuf->chars + strbuf->length - endLength, end, endLength) == 0;
 }
 
-static inline FF_C_NODISCARD bool ffStrbufEndsWithS(const FFstrbuf* strbuf, const char* end)
-{
+[[nodiscard]] static inline bool ffStrbufEndsWithS(const FFstrbuf* strbuf, const char* end) {
     return ffStrbufEndsWithNS(strbuf, (uint32_t) strlen(end), end);
 }
 
-static inline FF_C_NODISCARD bool ffStrbufEndsWithFn(const FFstrbuf* strbuf, int (*const fn)(int))
-{
-    return strbuf->length == 0 ? false :
-        fn(strbuf->chars[strbuf->length - 1]);
+[[nodiscard]] static inline bool ffStrbufEndsWithFn(const FFstrbuf* strbuf, int (*const fn)(int)) {
+    return strbuf->length == 0 ? false : fn(strbuf->chars[strbuf->length - 1]);
 }
 
-static inline FF_C_NODISCARD bool ffStrbufEndsWith(const FFstrbuf* strbuf, const FFstrbuf* end)
-{
+[[nodiscard]] static inline bool ffStrbufEndsWith(const FFstrbuf* strbuf, const FFstrbuf* end) {
     return ffStrbufEndsWithNS(strbuf, end->length, end->chars);
 }
 
-static inline FF_C_NODISCARD bool ffStrbufEndsWithIgnCaseNS(const FFstrbuf* strbuf, uint32_t endLength, const char* end)
-{
-    if(endLength > strbuf->length)
+[[nodiscard]] static inline bool ffStrbufEndsWithIgnCaseNS(const FFstrbuf* strbuf, uint32_t endLength, const char* end) {
+    if (endLength > strbuf->length) {
         return false;
+    }
     return strcasecmp(strbuf->chars + strbuf->length - endLength, end) == 0;
 }
 
-static inline FF_C_NODISCARD bool ffStrbufEndsWithIgnCaseS(const FFstrbuf* strbuf, const char* end)
-{
+[[nodiscard]] static inline bool ffStrbufEndsWithIgnCaseS(const FFstrbuf* strbuf, const char* end) {
     return ffStrbufEndsWithIgnCaseNS(strbuf, (uint32_t) strlen(end), end);
 }
 
-static inline FF_C_NODISCARD bool ffStrbufEndsWithIgnCase(const FFstrbuf* strbuf, const FFstrbuf* end)
-{
+[[nodiscard]] static inline bool ffStrbufEndsWithIgnCase(const FFstrbuf* strbuf, const FFstrbuf* end) {
     return ffStrbufEndsWithIgnCaseNS(strbuf, end->length, end->chars);
 }
 
-static inline void ffStrbufTrim(FFstrbuf* strbuf, char c)
-{
+static inline void ffStrbufTrim(FFstrbuf* strbuf, char c) {
     ffStrbufTrimRight(strbuf, c);
     ffStrbufTrimLeft(strbuf, c);
 }
 
-static inline void ffStrbufTrimSpace(FFstrbuf* strbuf)
-{
+static inline void ffStrbufTrimSpace(FFstrbuf* strbuf) {
     ffStrbufTrimRightSpace(strbuf);
     ffStrbufTrimLeftSpace(strbuf);
 }
 
-static inline bool ffStrbufMatchSeparatedS(const FFstrbuf* strbuf, const char* comp, char separator)
-{
+static inline bool ffStrbufMatchSeparatedS(const FFstrbuf* strbuf, const char* comp, char separator) {
     return ffStrbufMatchSeparatedNS(strbuf, (uint32_t) strlen(comp), comp, separator);
 }
 
-static inline bool ffStrbufMatchSeparated(const FFstrbuf* strbuf, const FFstrbuf* comp, char separator)
-{
+static inline bool ffStrbufMatchSeparated(const FFstrbuf* strbuf, const FFstrbuf* comp, char separator) {
     return ffStrbufMatchSeparatedNS(strbuf, comp->length, comp->chars, separator);
 }
 
-static inline bool ffStrbufMatchSeparatedIgnCaseS(const FFstrbuf* strbuf, const char* comp, char separator)
-{
+static inline bool ffStrbufMatchSeparatedIgnCaseS(const FFstrbuf* strbuf, const char* comp, char separator) {
     return ffStrbufMatchSeparatedIgnCaseNS(strbuf, (uint32_t) strlen(comp), comp, separator);
 }
 
-static inline bool ffStrbufMatchSeparatedIgnCase(const FFstrbuf* strbuf, const FFstrbuf* comp, char separator)
-{
+static inline bool ffStrbufMatchSeparatedIgnCase(const FFstrbuf* strbuf, const FFstrbuf* comp, char separator) {
     return ffStrbufMatchSeparatedIgnCaseNS(strbuf, comp->length, comp->chars, separator);
 }
 
-static inline bool ffStrbufSeparatedContainS(const FFstrbuf* strbuf, const char* comp, char separator)
-{
+static inline bool ffStrbufSeparatedContainS(const FFstrbuf* strbuf, const char* comp, char separator) {
     return ffStrbufSeparatedContainNS(strbuf, (uint32_t) strlen(comp), comp, separator);
 }
 
-static inline bool ffStrbufSeparatedContain(const FFstrbuf* strbuf, const FFstrbuf* comp, char separator)
-{
+static inline bool ffStrbufSeparatedContain(const FFstrbuf* strbuf, const FFstrbuf* comp, char separator) {
     return ffStrbufSeparatedContainNS(strbuf, comp->length, comp->chars, separator);
 }
 
-static inline bool ffStrbufSeparatedContainIgnCaseS(const FFstrbuf* strbuf, const char* comp, char separator)
-{
+static inline bool ffStrbufSeparatedContainIgnCaseS(const FFstrbuf* strbuf, const char* comp, char separator) {
     return ffStrbufSeparatedContainIgnCaseNS(strbuf, (uint32_t) strlen(comp), comp, separator);
 }
 
-static inline bool ffStrbufSeparatedContainIgnCase(const FFstrbuf* strbuf, const FFstrbuf* comp, char separator)
-{
+static inline bool ffStrbufSeparatedContainIgnCase(const FFstrbuf* strbuf, const FFstrbuf* comp, char separator) {
     return ffStrbufSeparatedContainIgnCaseNS(strbuf, comp->length, comp->chars, separator);
 }
 
-#define FF_STRBUF_AUTO_DESTROY FFstrbuf __attribute__((__cleanup__(ffStrbufDestroy)))
+static inline void ffStrbufWriteTo(const FFstrbuf* strbuf, FILE* file) {
+    fwrite(strbuf->chars, sizeof(*strbuf->chars), strbuf->length, file);
+}
+
+static inline void ffStrbufPutTo(const FFstrbuf* strbuf, FILE* file) {
+    ffStrbufWriteTo(strbuf, file);
+    fputc('\n', file);
+}
+
+[[nodiscard]] static inline double ffStrbufToDouble(const FFstrbuf* strbuf, double defaultValue) {
+    char* str_end;
+    double result = strtod(strbuf->chars, &str_end);
+    return str_end == strbuf->chars ? defaultValue : result;
+}
+
+[[nodiscard]] static inline uint64_t ffStrbufToUInt(const FFstrbuf* strbuf, uint64_t defaultValue) {
+    char* str_end;
+    unsigned long long result = strtoull(strbuf->chars, &str_end, 10);
+    return str_end == strbuf->chars ? defaultValue : (uint64_t) result;
+}
+
+[[nodiscard]] static inline int64_t ffStrbufToSInt(const FFstrbuf* strbuf, int64_t defaultValue) {
+    char* str_end;
+    long long result = strtoll(strbuf->chars, &str_end, 10);
+    return str_end == strbuf->chars ? defaultValue : (int64_t) result;
+}
+
+// Returns true if the strbuf is modified
+bool ffStrbufDecodeHexEscapeSequences(FFstrbuf* strbuf);
+
+#define FF_STRBUF_AUTO_DESTROY [[gnu::cleanup(ffStrbufDestroy)]] FFstrbuf
+#define FF_STRBUF_STATIC(str) { .allocated = 0, .length = (uint32_t) sizeof(str) - 1, .chars = str }

src/common/apple/cf_helpers.c

@@ -1,185 +1,225 @@
 #include "cf_helpers.h"
 
-const char* ffCfNumGetInt64(CFTypeRef cf, int64_t* result)
-{
-    if(CFGetTypeID(cf) == CFNumberGetTypeID())
-    {
-        if(!CFNumberGetValue((CFNumberRef)cf, kCFNumberSInt64Type, result))
+const char* ffCfNumGetInt64(CFTypeRef cf, int64_t* result) {
+    if (CFGetTypeID(cf) == CFNumberGetTypeID()) {
+        if (!CFNumberGetValue((CFNumberRef) cf, kCFNumberSInt64Type, result)) {
             return "Number type is not SInt64";
-        return NULL;
-    }
-    else if(CFGetTypeID(cf) == CFDataGetTypeID())
-    {
-        if(CFDataGetLength((CFDataRef)cf) != sizeof(int64_t))
+        }
+        return nullptr;
+    } else if (CFGetTypeID(cf) == CFDataGetTypeID()) {
+        if (CFDataGetLength((CFDataRef) cf) != sizeof(int64_t)) {
             return "Data length is not sizeof(int64_t)";
-        CFDataGetBytes((CFDataRef)cf, CFRangeMake(0, sizeof(int64_t)), (uint8_t*)result);
-        return NULL;
+        }
+        CFDataGetBytes((CFDataRef) cf, CFRangeMake(0, sizeof(int64_t)), (uint8_t*) result);
+        return nullptr;
     }
 
     return "TypeID is neither 'CFNumber' nor 'CFData'";
 }
 
-const char* ffCfNumGetInt(CFTypeRef cf, int32_t* result)
-{
-    if(CFGetTypeID(cf) == CFNumberGetTypeID())
-    {
-        if(!CFNumberGetValue((CFNumberRef)cf, kCFNumberSInt32Type, result))
+const char* ffCfNumGetInt(CFTypeRef cf, int32_t* result) {
+    if (CFGetTypeID(cf) == CFNumberGetTypeID()) {
+        if (!CFNumberGetValue((CFNumberRef) cf, kCFNumberSInt32Type, result)) {
             return "Number type is not SInt32";
-        return NULL;
-    }
-    else if(CFGetTypeID(cf) == CFDataGetTypeID())
-    {
-        if(CFDataGetLength((CFDataRef)cf) != sizeof(int))
-            return "Data length is not sizeof(int)";
-        CFDataGetBytes((CFDataRef)cf, CFRangeMake(0, sizeof(int)), (uint8_t*)result);
-        return NULL;
+        }
+        return nullptr;
+    } else if (CFGetTypeID(cf) == CFDataGetTypeID()) {
+        if (CFDataGetLength((CFDataRef) cf) != sizeof(*result)) {
+            return "Data length is not sizeof(int32_t)";
+        }
+        CFDataGetBytes((CFDataRef) cf, CFRangeMake(0, sizeof(*result)), (uint8_t*) result);
+        return nullptr;
     }
 
     return "TypeID is neither 'CFNumber' nor 'CFData'";
 }
 
-const char* ffCfStrGetString(CFTypeRef cf, FFstrbuf* result)
-{
-    ffStrbufClear(result);
-    if (!cf)
-        return NULL;
+const char* ffCfNumGetDouble(CFTypeRef cf, double* result) {
+    if (CFGetTypeID(cf) == CFNumberGetTypeID()) {
+        if (!CFNumberGetValue((CFNumberRef) cf, kCFNumberDoubleType, result) &&
+            !CFNumberGetValue((CFNumberRef) cf, kCFNumberFloatType, result)) {
+            return "Number type is not Double or Float";
+        }
+        return nullptr;
+    }
 
-    if (CFGetTypeID(cf) == CFStringGetTypeID())
-    {
-        CFStringRef cfStr = (CFStringRef)cf;
+    return "TypeID is neither 'CFNumber'";
+}
+
+const char* ffCfDateGetEpoch(CFTypeRef cf, uint64_t* result) {
+    if (CFGetTypeID(cf) != CFDateGetTypeID()) {
+        return "TypeID is not 'CFDate'";
+    }
+
+    CFAbsoluteTime absTime = CFDateGetAbsoluteTime((CFDateRef) cf);
+    // Convert from seconds to milliseconds and add the difference between 1970 and 2001 in milliseconds
+    *result = (uint64_t) ((absTime + 978307200 /*kCFAbsoluteTimeIntervalSince1970*/) * 1000);
+    return nullptr;
+}
+
+const char* ffCfStrGetString(CFTypeRef cf, FFstrbuf* result) {
+    ffStrbufClear(result);
+    if (!cf) {
+        return nullptr;
+    }
+
+    if (CFGetTypeID(cf) == CFStringGetTypeID()) {
+        CFStringRef cfStr = (CFStringRef) cf;
 
         const char* cstr = CFStringGetCStringPtr(cfStr, kCFStringEncodingUTF8);
-        if (cstr)
+        if (cstr) {
             ffStrbufSetS(result, cstr);
-        else
-        {
+        } else {
             uint32_t length = (uint32_t) CFStringGetLength(cfStr);
-            if (length == 0)
-                return NULL;
+            if (length == 0) {
+                return nullptr;
+            }
             ffStrbufEnsureFixedLengthFree(result, (uint32_t) CFStringGetMaximumSizeForEncoding(length, kCFStringEncodingUTF8));
-            if(!CFStringGetCString(cfStr, result->chars, result->allocated, kCFStringEncodingUTF8))
+            if (!CFStringGetCString(cfStr, result->chars, result->allocated, kCFStringEncodingUTF8)) {
                 return "CFStringGetCString() failed";
+            }
             // CFStringGetCString ensures the buffer is NUL terminated
             // https://developer.apple.com/documentation/corefoundation/1542721-cfstringgetcstring
-            result->length = (uint32_t) strnlen(result->chars, (uint32_t)result->allocated);
+            result->length = (uint32_t) strnlen(result->chars, (uint32_t) result->allocated);
+        }
+    } else if (CFGetTypeID(cf) == CFDataGetTypeID()) {
+        CFDataRef cfData = (CFDataRef) cf;
+        uint32_t length = (uint32_t) CFDataGetLength(cfData);
+        if (length == 0) {
+            return nullptr;
         }
-    }
-    else if (CFGetTypeID(cf) == CFDataGetTypeID())
-    {
-        CFDataRef cfData = (CFDataRef)cf;
-        uint32_t length = (uint32_t)CFDataGetLength(cfData);
-        if (length == 0)
-            return NULL;
         ffStrbufEnsureFixedLengthFree(result, length + 1);
-        CFDataGetBytes(cfData, CFRangeMake(0, length), (uint8_t*)result->chars);
-        result->length = (uint32_t)strnlen(result->chars, length);
+        CFDataGetBytes(cfData, CFRangeMake(0, length), (uint8_t*) result->chars);
+        result->length = (uint32_t) strnlen(result->chars, length);
         result->chars[result->length] = '\0';
-    }
-    else
+    } else {
         return "TypeID is neither 'CFString' nor 'CFData'";
+    }
 
-    return NULL;
+    return nullptr;
 }
 
-const char* ffCfDataGetDataAsString(CFTypeRef cf, FFstrbuf* result)
-{
+const char* ffCfDataGetDataAsString(CFTypeRef cf, FFstrbuf* result) {
     ffStrbufClear(result);
-    if (!cf)
-        return NULL;
+    if (!cf) {
+        return nullptr;
+    }
 
-    if (CFGetTypeID(cf) == CFDataGetTypeID())
-    {
-        CFDataRef cfData = (CFDataRef)cf;
-        uint32_t length = (uint32_t)CFDataGetLength(cfData);
-        if (length == 0)
-            return NULL;
+    if (CFGetTypeID(cf) == CFDataGetTypeID()) {
+        CFDataRef cfData = (CFDataRef) cf;
+        uint32_t length = (uint32_t) CFDataGetLength(cfData);
+        if (length == 0) {
+            return nullptr;
+        }
         ffStrbufEnsureFixedLengthFree(result, length + 1);
-        CFDataGetBytes(cfData, CFRangeMake(0, length), (uint8_t*)result->chars);
+        CFDataGetBytes(cfData, CFRangeMake(0, length), (uint8_t*) result->chars);
         result->length = length;
         result->chars[result->length] = '\0';
-    }
-    else
+    } else {
         return "TypeID is not 'CFData'";
+    }
 
-    return NULL;
+    return nullptr;
 }
 
-const char* ffCfDictGetString(CFDictionaryRef dict, CFStringRef key, FFstrbuf* result)
-{
-    CFTypeRef cf = (CFTypeRef)CFDictionaryGetValue(dict, key);
-    if(cf == NULL)
+const char* ffCfDictGetString(CFDictionaryRef dict, CFStringRef key, FFstrbuf* result) {
+    CFTypeRef cf = (CFTypeRef) CFDictionaryGetValue(dict, key);
+    if (cf == nullptr) {
         return "CFDictionaryGetValue() failed";
+    }
 
     return ffCfStrGetString(cf, result);
 }
 
-const char* ffCfDictGetDataAsString(CFDictionaryRef dict, CFStringRef key, FFstrbuf* result)
-{
-    CFTypeRef cf = (CFTypeRef)CFDictionaryGetValue(dict, key);
-    if(cf == NULL)
+const char* ffCfDictGetDataAsString(CFDictionaryRef dict, CFStringRef key, FFstrbuf* result) {
+    CFTypeRef cf = (CFTypeRef) CFDictionaryGetValue(dict, key);
+    if (cf == nullptr) {
         return "CFDictionaryGetValue() failed";
+    }
 
     return ffCfDataGetDataAsString(cf, result);
 }
 
-const char* ffCfDictGetBool(CFDictionaryRef dict, CFStringRef key, bool* result)
-{
-    CFBooleanRef cf = (CFBooleanRef)CFDictionaryGetValue(dict, key);
-    if(cf == NULL)
+const char* ffCfDictGetBool(CFDictionaryRef dict, CFStringRef key, bool* result) {
+    CFBooleanRef cf = (CFBooleanRef) CFDictionaryGetValue(dict, key);
+    if (cf == nullptr) {
         return "CFDictionaryGetValue() failed";
+    }
 
-    if(CFGetTypeID(cf) != CFBooleanGetTypeID())
+    if (CFGetTypeID(cf) != CFBooleanGetTypeID()) {
         return "TypeID is not 'CFBoolean'";
+    }
 
     *result = CFBooleanGetValue(cf);
-    return NULL;
+    return nullptr;
 }
 
-const char* ffCfDictGetInt(CFDictionaryRef dict, CFStringRef key, int* result)
-{
-    CFTypeRef cf = (CFTypeRef)CFDictionaryGetValue(dict, key);
-    if(cf == NULL)
+const char* ffCfDictGetInt(CFDictionaryRef dict, CFStringRef key, int* result) {
+    CFTypeRef cf = (CFTypeRef) CFDictionaryGetValue(dict, key);
+    if (cf == nullptr) {
         return "CFDictionaryGetValue() failed";
+    }
 
     return ffCfNumGetInt(cf, result);
 }
 
-const char* ffCfDictGetInt64(CFDictionaryRef dict, CFStringRef key, int64_t* result)
-{
-    CFTypeRef cf = (CFTypeRef)CFDictionaryGetValue(dict, key);
-    if(cf == NULL)
+const char* ffCfDictGetInt64(CFDictionaryRef dict, CFStringRef key, int64_t* result) {
+    CFTypeRef cf = (CFTypeRef) CFDictionaryGetValue(dict, key);
+    if (cf == nullptr) {
         return "CFDictionaryGetValue() failed";
+    }
 
     return ffCfNumGetInt64(cf, result);
 }
 
-const char* ffCfDictGetData(CFDictionaryRef dict, CFStringRef key, uint32_t offset, uint32_t size, uint8_t* result, uint32_t* length)
-{
-    CFTypeRef cf = (CFTypeRef)CFDictionaryGetValue(dict, key);
-    if(cf == NULL)
+const char* ffCfDictGetDouble(CFDictionaryRef dict, CFStringRef key, double* result) {
+    CFTypeRef cf = (CFTypeRef) CFDictionaryGetValue(dict, key);
+    if (cf == nullptr) {
         return "CFDictionaryGetValue() failed";
+    }
 
-    if(CFGetTypeID(cf) != CFDataGetTypeID())
-        return "TypeID is not 'CFData'";
-
-    CFIndex trueLength = CFDataGetLength((CFDataRef)cf);
-
-    if(trueLength < offset + size)
-        return "Data length is less than offset + size";
-
-    if(length)
-        *length = (uint32_t) trueLength;
-
-    CFDataGetBytes((CFDataRef)cf, CFRangeMake(offset, size), result);
-    return NULL;
+    return ffCfNumGetDouble(cf, result);
 }
 
-const char* ffCfDictGetDict(CFDictionaryRef dict, CFStringRef key, CFDictionaryRef* result)
-{
-    CFDictionaryRef cf = (CFDictionaryRef)CFDictionaryGetValue(dict, key);
-    if (cf == NULL || CFGetTypeID(cf) != CFDictionaryGetTypeID())
+const char* ffCfDictGetData(CFDictionaryRef dict, CFStringRef key, uint32_t offset, uint32_t size, uint8_t* result, uint32_t* length) {
+    CFTypeRef cf = (CFTypeRef) CFDictionaryGetValue(dict, key);
+    if (cf == nullptr) {
+        return "CFDictionaryGetValue() failed";
+    }
+
+    if (CFGetTypeID(cf) != CFDataGetTypeID()) {
+        return "TypeID is not 'CFData'";
+    }
+
+    CFIndex trueLength = CFDataGetLength((CFDataRef) cf);
+
+    if (trueLength < offset + size) {
+        return "Data length is less than offset + size";
+    }
+
+    if (length) {
+        *length = (uint32_t) trueLength;
+    }
+
+    CFDataGetBytes((CFDataRef) cf, CFRangeMake(offset, size), result);
+    return nullptr;
+}
+
+const char* ffCfDictGetDict(CFDictionaryRef dict, CFStringRef key, CFDictionaryRef* result) {
+    CFDictionaryRef cf = (CFDictionaryRef) CFDictionaryGetValue(dict, key);
+    if (cf == nullptr || CFGetTypeID(cf) != CFDictionaryGetTypeID()) {
         return "TypeID is not 'CFDictionary'";
+    }
 
     *result = cf;
-    return NULL;
+    return nullptr;
+}
+
+const char* ffCfDictGetDateAsEpoch(CFDictionaryRef dict, CFStringRef key, uint64_t* result) {
+    CFTypeRef cf = (CFTypeRef) CFDictionaryGetValue(dict, key);
+    if (cf == nullptr) {
+        return "CFDictionaryGetValue() failed";
+    }
+
+    return ffCfDateGetEpoch(cf, result);
 }

src/common/apple/cf_helpers.h

@@ -4,37 +4,40 @@
 #include <CoreFoundation/CoreFoundation.h>
 #include <IOKit/IOKitLib.h>
 
-//Return error info if failed, NULL otherwise
+// Return error info if failed, nullptr otherwise
 const char* ffCfStrGetString(CFTypeRef cf, FFstrbuf* result);
 const char* ffCfNumGetInt(CFTypeRef cf, int32_t* result);
 const char* ffCfNumGetInt64(CFTypeRef cf, int64_t* result);
+const char* ffCfNumGetDouble(CFTypeRef cf, double* result);
+const char* ffCfDateGetEpoch(CFTypeRef cf, uint64_t* result);
 const char* ffCfDataGetDataAsString(CFTypeRef cf, FFstrbuf* result);
 const char* ffCfDictGetString(CFDictionaryRef dict, CFStringRef key, FFstrbuf* result);
 const char* ffCfDictGetBool(CFDictionaryRef dict, CFStringRef key, bool* result);
 const char* ffCfDictGetInt(CFDictionaryRef dict, CFStringRef key, int* result);
 const char* ffCfDictGetInt64(CFDictionaryRef dict, CFStringRef key, int64_t* result);
+const char* ffCfDictGetDouble(CFDictionaryRef dict, CFStringRef key, double* result);
 const char* ffCfDictGetData(CFDictionaryRef dict, CFStringRef key, uint32_t offset, uint32_t size, uint8_t* result, uint32_t* length);
 const char* ffCfDictGetDataAsString(CFDictionaryRef dict, CFStringRef key, FFstrbuf* result);
 const char* ffCfDictGetDict(CFDictionaryRef dict, CFStringRef key, CFDictionaryRef* result);
+const char* ffCfDictGetDateAsEpoch(CFDictionaryRef dict, CFStringRef key, uint64_t* result);
 
-static inline CFNumberRef ffCfCreateInt(int value)
-{
+static inline CFNumberRef ffCfCreateInt(int value) {
     return CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &value);
 }
 
-static inline void cfReleaseWrapper(void* type)
-{
+static inline void cfReleaseWrapper(void* type) {
     assert(type);
-    if (*(CFTypeRef*) type)
+    if (*(CFTypeRef*) type) {
         CFRelease(*(CFTypeRef*) type);
+    }
 }
 
-#define FF_CFTYPE_AUTO_RELEASE __attribute__((__cleanup__(cfReleaseWrapper)))
+#define FF_CFTYPE_AUTO_RELEASE [[gnu::cleanup(cfReleaseWrapper)]]
 
-static inline void wrapIoObjectRelease(io_object_t* service)
-{
+static inline void wrapIoObjectRelease(io_object_t* service) {
     assert(service);
-    if (*service)
+    if (*service) {
         IOObjectRelease(*service);
+    }
 }
-#define FF_IOOBJECT_AUTO_RELEASE __attribute__((__cleanup__(wrapIoObjectRelease)))
+#define FF_IOOBJECT_AUTO_RELEASE [[gnu::cleanup(wrapIoObjectRelease)]]

src/common/apple/osascript.m

@@ -1,8 +1,6 @@
 #include "osascript.h"
 
 #import <Foundation/Foundation.h>
-#import <AppKit/AppKit.h>
-#import <CoreData/CoreData.h>
 
 bool ffOsascript(const char* input, FFstrbuf* result)
 {

src/common/apple/smc_temps.c

@@ -1,9 +1,8 @@
 #include "smc_temps.h"
 #include "common/apple/cf_helpers.h"
-#include "common/stringUtils.h"
+#include "common/strutil.h"
 
 #include <stdint.h>
-#include <math.h>
 #include <IOKit/IOKitLib.h>
 
 static const char kSmcCmdReadBytes = 5;
@@ -60,66 +59,64 @@ typedef struct
     SmcBytes_t bytes;
 } SmcVal_t;
 
-static uint32_t smcStrtoul(const char *str, int size, int base)
-{
+static uint32_t smcStrtoul(const char* str, int size, int base) {
     uint32_t total = 0;
 
-    for (int i = 0; i < size; i++)
-    {
-        if (base == 16)
-            total += (uint32_t)(str[i] << (size - 1 - i) * 8);
-        else
-            total += (uint32_t)((unsigned char)(str[i]) << (size - 1 - i) * 8);
+    for (int i = 0; i < size; i++) {
+        if (base == 16) {
+            total += (uint32_t) (str[i] << (size - 1 - i) * 8);
+        } else {
+            total += (uint32_t) ((unsigned char) (str[i]) << (size - 1 - i) * 8);
+        }
     }
     return total;
 }
 
-static void smcUltostr(char *str, uint32_t val)
-{
-    str[0] = (char)(val >> 24);
-    str[1] = (char)(val >> 16);
-    str[2] = (char)(val >> 8);
-    str[3] = (char)val;
+static void smcUltostr(char* str, uint32_t val) {
+    str[0] = (char) (val >> 24);
+    str[1] = (char) (val >> 16);
+    str[2] = (char) (val >> 8);
+    str[3] = (char) val;
     str[4] = '\0';
 }
 
-static const char *smcCall(io_connect_t conn, uint32_t selector, SmcKeyData_t *inputStructure, SmcKeyData_t *outputStructure)
-{
+static const char* smcCall(io_connect_t conn, uint32_t selector, SmcKeyData_t* inputStructure, SmcKeyData_t* outputStructure) {
     size_t size = sizeof(SmcKeyData_t);
 
-    if (IOConnectCallStructMethod(conn, selector, inputStructure, size, outputStructure, &size) != kIOReturnSuccess)
+    if (IOConnectCallStructMethod(conn, selector, inputStructure, size, outputStructure, &size) != kIOReturnSuccess) {
         return "IOConnectCallStructMethod(conn) failed";
-    return NULL;
+    }
+    return nullptr;
 }
 
 // Provides key info, using a cache to dramatically improve the energy impact of smcFanControl
-static const char *smcGetKeyInfo(io_connect_t conn, const uint32_t key, SmcKeyData_keyInfo_t *key_info)
-{
-    SmcKeyData_t inputStructure = {0};
-    SmcKeyData_t outputStructure = {0};
+static const char* smcGetKeyInfo(io_connect_t conn, const uint32_t key, SmcKeyData_keyInfo_t* key_info) {
+    SmcKeyData_t inputStructure = { 0 };
+    SmcKeyData_t outputStructure = { 0 };
 
     inputStructure.key = key;
     inputStructure.data8 = kSmcCmdReadKeyInfo;
 
-    const char *error = smcCall(conn, kKernelIndexSmc, &inputStructure, &outputStructure);
-    if (error)
+    const char* error = smcCall(conn, kKernelIndexSmc, &inputStructure, &outputStructure);
+    if (error) {
         return error;
+    }
 
     *key_info = outputStructure.keyInfo;
-    return NULL;
+    return nullptr;
 }
 
-static const char *smcReadSmcVal(io_connect_t conn, const UInt32Char_t key, SmcVal_t *val)
-{
-    SmcKeyData_t inputStructure = {0};
-    SmcKeyData_t outputStructure = {0};
+static const char* smcReadSmcVal(io_connect_t conn, const UInt32Char_t key, SmcVal_t* val) {
+    SmcKeyData_t inputStructure = { 0 };
+    SmcKeyData_t outputStructure = { 0 };
 
     inputStructure.key = smcStrtoul(key, 4, 16);
     strcpy(val->key, key);
 
-    const char *error = smcGetKeyInfo(conn, inputStructure.key, &outputStructure.keyInfo);
-    if (error)
+    const char* error = smcGetKeyInfo(conn, inputStructure.key, &outputStructure.keyInfo);
+    if (error) {
         return error;
+    }
 
     val->dataSize = outputStructure.keyInfo.dataSize;
     smcUltostr(val->dataType, outputStructure.keyInfo.dataType);
@@ -127,323 +124,377 @@ static const char *smcReadSmcVal(io_connect_t conn, const UInt32Char_t key, SmcV
     inputStructure.data8 = kSmcCmdReadBytes;
 
     error = smcCall(conn, kKernelIndexSmc, &inputStructure, &outputStructure);
-    if (error)
+    if (error) {
         return error;
+    }
 
     memcpy(val->bytes, outputStructure.bytes, sizeof(outputStructure.bytes));
 
-    return NULL;
+    return nullptr;
 }
 
-static const char *smcOpen(io_connect_t *conn)
-{
+static const char* smcOpen(io_connect_t* conn) {
     FF_IOOBJECT_AUTO_RELEASE io_object_t device = IOServiceGetMatchingService(MACH_PORT_NULL, IOServiceMatching("AppleSMC"));
-    if (!device)
+    if (!device) {
         return "No SMC device found";
+    }
 
-    if (IOServiceOpen(device, mach_task_self(), 0, conn) != kIOReturnSuccess)
+    if (IOServiceOpen(device, mach_task_self(), 0, conn) != kIOReturnSuccess) {
         return "IOServiceOpen() failed";
+    }
 
-    return NULL;
+    return nullptr;
 }
 
-static const char *smcReadValue(io_connect_t conn, const UInt32Char_t key, double *value)
-{
-    SmcVal_t val = {0};
+static const char* smcReadValue(io_connect_t conn, const UInt32Char_t key, double* value) {
+    SmcVal_t val = { 0 };
     const char* error = smcReadSmcVal(conn, key, &val);
-    if (error != NULL)
+    if (error != nullptr) {
         return error;
-    if (val.dataSize == 0)
+    }
+    if (val.dataSize == 0) {
         return "Empty SMC result";
+    }
 
-    switch (val.dataType[0])
-    {
+    switch (val.dataType[0]) {
         case 'u': // unsigned integer types
-            if (val.dataType[1] == 'i')
-            {
-                switch (val.dataSize)
-                {
-                    case 1: *value = *(uint8_t *)(val.bytes); break;
-                    case 2: *value = ntohs(*(uint16_t *)(val.bytes)); break;
-                    case 4: *value = ntohl(*(uint32_t *)(val.bytes)); break;
-                    case 8: *value = (double) ntohll(*(uint64_t *)(val.bytes)); break;
+            if (val.dataType[1] == 'i') {
+                switch (val.dataSize) {
+                    case 1:
+                        *value = *(uint8_t*) (val.bytes);
+                        break;
+                    case 2:
+                        *value = ntohs(*(uint16_t*) (val.bytes));
+                        break;
+                    case 4:
+                        *value = ntohl(*(uint32_t*) (val.bytes));
+                        break;
+                    case 8:
+                        *value = (double) ntohll(*(uint64_t*) (val.bytes));
+                        break;
                     default:
                         return "Unsupported SMC unsigned integer data size";
                 }
-            }
-            else
+            } else {
                 return "Unsupported SMC unsigned data type";
+            }
             break;
 
         case 'f': // floating point types
-            if (ffStrEquals(val.dataType, "flt ") && val.dataSize == 4)
-                *value = *(float *)(val.bytes);
-            else if (val.dataType[1] == 'p' && val.dataSize == 2) // fixed point types
+            if (ffStrEquals(val.dataType, "flt ") && val.dataSize == 4) {
+                *value = *(float*) (val.bytes);
+            } else if (val.dataType[1] == 'p' && val.dataSize == 2) // fixed point types
             {
-                if (ffStrEquals(val.dataType, "fp1f"))
-                    *value = ntohs(*(uint16_t *)(val.bytes)) / 32768.0;
-                else if (ffStrEquals(val.dataType, "fp4c"))
-                    *value = ntohs(*(uint16_t *)(val.bytes)) / 4096.0;
-                else if (ffStrEquals(val.dataType, "fp5b"))
-                    *value = ntohs(*(uint16_t *)(val.bytes)) / 2048.0;
-                else if (ffStrEquals(val.dataType, "fp6a"))
-                    *value = ntohs(*(uint16_t *)(val.bytes)) / 1024.0;
-                else if (ffStrEquals(val.dataType, "fp79"))
-                    *value = ntohs(*(uint16_t *)(val.bytes)) / 512.0;
-                else if (ffStrEquals(val.dataType, "fp88"))
-                    *value = ntohs(*(uint16_t *)(val.bytes)) / 256.0;
-                else if (ffStrEquals(val.dataType, "fpa6"))
-                    *value = ntohs(*(uint16_t *)(val.bytes)) / 64.0;
-                else if (ffStrEquals(val.dataType, "fpc4"))
-                    *value = ntohs(*(uint16_t *)(val.bytes)) / 16.0;
-                else if (ffStrEquals(val.dataType, "fpe2"))
-                    *value = ntohs(*(uint16_t *)(val.bytes)) / 4.0;
-                else
+                if (ffStrEquals(val.dataType, "fp1f")) {
+                    *value = ntohs(*(uint16_t*) (val.bytes)) / 32768.0;
+                } else if (ffStrEquals(val.dataType, "fp4c")) {
+                    *value = ntohs(*(uint16_t*) (val.bytes)) / 4096.0;
+                } else if (ffStrEquals(val.dataType, "fp5b")) {
+                    *value = ntohs(*(uint16_t*) (val.bytes)) / 2048.0;
+                } else if (ffStrEquals(val.dataType, "fp6a")) {
+                    *value = ntohs(*(uint16_t*) (val.bytes)) / 1024.0;
+                } else if (ffStrEquals(val.dataType, "fp79")) {
+                    *value = ntohs(*(uint16_t*) (val.bytes)) / 512.0;
+                } else if (ffStrEquals(val.dataType, "fp88")) {
+                    *value = ntohs(*(uint16_t*) (val.bytes)) / 256.0;
+                } else if (ffStrEquals(val.dataType, "fpa6")) {
+                    *value = ntohs(*(uint16_t*) (val.bytes)) / 64.0;
+                } else if (ffStrEquals(val.dataType, "fpc4")) {
+                    *value = ntohs(*(uint16_t*) (val.bytes)) / 16.0;
+                } else if (ffStrEquals(val.dataType, "fpe2")) {
+                    *value = ntohs(*(uint16_t*) (val.bytes)) / 4.0;
+                } else {
                     return "Unsupported SMC floating point data type";
-            }
-            else
+                }
+            } else {
                 return "Unsupported SMC floating point data type";
+            }
             break;
 
         case 's': // signed integer types
-            if (val.dataType[1] == 'i')
-            {
-                switch (val.dataSize)
-                {
-                    case 1: *value = *(int8_t *)(val.bytes); break;
-                    case 2: *value = ntohs(*(int16_t *)(val.bytes)); break;
-                    case 4: *value = ntohl(*(int32_t *)(val.bytes)); break;
-                    case 8: *value = (double)ntohll(*(int64_t *)(val.bytes)); break;
-                    default: return "Unsupported SMC signed integer data size";
+            if (val.dataType[1] == 'i') {
+                switch (val.dataSize) {
+                    case 1:
+                        *value = *(int8_t*) (val.bytes);
+                        break;
+                    case 2:
+                        *value = ntohs(*(int16_t*) (val.bytes));
+                        break;
+                    case 4:
+                        *value = ntohl(*(int32_t*) (val.bytes));
+                        break;
+                    case 8:
+                        *value = (double) ntohll(*(int64_t*) (val.bytes));
+                        break;
+                    default:
+                        return "Unsupported SMC signed integer data size";
                 }
-            }
-            else if (val.dataType[1] == 'p' && val.dataSize == 2) // signed fixed point types
+            } else if (val.dataType[1] == 'p' && val.dataSize == 2) // signed fixed point types
             {
-                if (ffStrEquals(val.dataType, "sp1e"))
-                    *value = (int16_t)ntohs(*(int16_t *)(val.bytes)) / 16384.0;
-                else if (ffStrEquals(val.dataType, "sp3c"))
-                    *value = (int16_t)ntohs(*(int16_t *)(val.bytes)) / 4096.0;
-                else if (ffStrEquals(val.dataType, "sp4b"))
-                    *value = (int16_t)ntohs(*(int16_t *)(val.bytes)) / 2048.0;
-                else if (ffStrEquals(val.dataType, "sp5a"))
-                    *value = (int16_t)ntohs(*(int16_t *)(val.bytes)) / 1024.0;
-                else if (ffStrEquals(val.dataType, "sp69"))
-                    *value = (int16_t)ntohs(*(int16_t *)(val.bytes)) / 512.0;
-                else if (ffStrEquals(val.dataType, "sp78"))
-                    *value = (int16_t)ntohs(*(int16_t *)(val.bytes)) / 256.0;
-                else if (ffStrEquals(val.dataType, "sp87"))
-                    *value = (int16_t)ntohs(*(int16_t *)(val.bytes)) / 128.0;
-                else if (ffStrEquals(val.dataType, "sp96"))
-                    *value = (int16_t)ntohs(*(int16_t *)(val.bytes)) / 64.0;
-                else if (ffStrEquals(val.dataType, "spb4"))
-                    *value = (int16_t)ntohs(*(int16_t *)(val.bytes)) / 16.0;
-                else if (ffStrEquals(val.dataType, "spf0"))
-                    *value = (int16_t)ntohs(*(int16_t *)(val.bytes)) / 1.0;
-                else
+                if (ffStrEquals(val.dataType, "sp1e")) {
+                    *value = (int16_t) ntohs(*(int16_t*) (val.bytes)) / 16384.0;
+                } else if (ffStrEquals(val.dataType, "sp3c")) {
+                    *value = (int16_t) ntohs(*(int16_t*) (val.bytes)) / 4096.0;
+                } else if (ffStrEquals(val.dataType, "sp4b")) {
+                    *value = (int16_t) ntohs(*(int16_t*) (val.bytes)) / 2048.0;
+                } else if (ffStrEquals(val.dataType, "sp5a")) {
+                    *value = (int16_t) ntohs(*(int16_t*) (val.bytes)) / 1024.0;
+                } else if (ffStrEquals(val.dataType, "sp69")) {
+                    *value = (int16_t) ntohs(*(int16_t*) (val.bytes)) / 512.0;
+                } else if (ffStrEquals(val.dataType, "sp78")) {
+                    *value = (int16_t) ntohs(*(int16_t*) (val.bytes)) / 256.0;
+                } else if (ffStrEquals(val.dataType, "sp87")) {
+                    *value = (int16_t) ntohs(*(int16_t*) (val.bytes)) / 128.0;
+                } else if (ffStrEquals(val.dataType, "sp96")) {
+                    *value = (int16_t) ntohs(*(int16_t*) (val.bytes)) / 64.0;
+                } else if (ffStrEquals(val.dataType, "spb4")) {
+                    *value = (int16_t) ntohs(*(int16_t*) (val.bytes)) / 16.0;
+                } else if (ffStrEquals(val.dataType, "spf0")) {
+                    *value = (int16_t) ntohs(*(int16_t*) (val.bytes)) / 1.0;
+                } else {
                     return "Unsupported SMC signed integer data type";
-            }
-            else
+                }
+            } else {
                 return "Unsupported SMC signed data type";
+            }
             break;
 
         case '{': // special types like pwm
-            if (ffStrEquals(val.dataType, "{pwm") && val.dataSize == 2)
-            {
-                *value = (double)ntohs(*(uint16_t *)(val.bytes)) * 100 / 65536.0;
-            }
-            else
+            if (ffStrEquals(val.dataType, "{pwm") && val.dataSize == 2) {
+                *value = (double) ntohs(*(uint16_t*) (val.bytes)) * 100 / 65536.0;
+            } else {
                 return "Unsupported SMC special data type";
+            }
             break;
 
         default:
             return "Unsupported SMC data type";
     }
-    return NULL;
+    return nullptr;
 }
 
-static bool detectTemp(io_connect_t conn, const char* sensor, double* sum)
-{
+static bool detectTemp(io_connect_t conn, const char* sensor, double* sum) {
     double temp = 0;
     const char* error = smcReadValue(conn, sensor, &temp);
-    if (error) return false;
+    if (error) {
+        return false;
+    }
     // https://github.com/exelban/stats/blob/14e29c4d60229c363cca9c9d25c30c87b7870830/Modules/Sensors/readers.swift#L124
-    if (temp < 10 || temp > 120) return false;
+    if (temp < 10 || temp > 120) {
+        return false;
+    }
     *sum += temp;
     return true;
 }
 
 static io_connect_t conn;
 
-const char* ffDetectSmcSpecificTemp(const char* sensor, double* result)
-{
-    if (!conn)
-    {
-        if (smcOpen(&conn) != NULL)
+const char* ffDetectSmcSpecificTemp(const char* sensor, double* result) {
+    if (!conn) {
+        if (smcOpen(&conn) != nullptr) {
             conn = (io_connect_t) -1;
+        }
     }
-    if (conn == (io_connect_t) -1)
+    if (conn == (io_connect_t) -1) {
         return "Could not open SMC connection";
+    }
 
-    if (!detectTemp(conn, sensor, result))
+    if (!detectTemp(conn, sensor, result)) {
         return "Could not read SMC temperature";
+    }
 
-    return NULL;
+    return nullptr;
 }
 
-const char* ffDetectSmcTemps(enum FFTempType type, double* result)
-{
-    if (!conn)
-    {
-        if (smcOpen(&conn) != NULL)
+const char* ffDetectSmcTemps(enum FFTempType type, double* result) {
+    if (!conn) {
+        if (smcOpen(&conn) != nullptr) {
             conn = (io_connect_t) -1;
+        }
     }
-    if (conn == (io_connect_t) -1)
+    if (conn == (io_connect_t) -1) {
         return "Could not open SMC connection";
+    }
 
     uint32_t count = 0;
     *result = 0;
 
     // https://github.com/exelban/stats/blob/master/Modules/Sensors/values.swift
-    switch (type)
-    {
-    case FF_TEMP_CPU_X64:
-        count += detectTemp(conn, "TC0D", result); // CPU diode
-        count += detectTemp(conn, "TC0E", result); // CPU diode virtual
-        count += detectTemp(conn, "TC0F", result); // CPU diode filtered
-        count += detectTemp(conn, "TC0P", result); // CPU proximity
-        break;
+    switch (type) {
+        case FF_TEMP_CPU_X64:
+            count += detectTemp(conn, "TC0D", result); // CPU diode
+            count += detectTemp(conn, "TC0E", result); // CPU diode virtual
+            count += detectTemp(conn, "TC0F", result); // CPU diode filtered
+            count += detectTemp(conn, "TC0P", result); // CPU proximity
+            break;
 
-    case FF_TEMP_CPU_M1X:
-        count += detectTemp(conn, "Tp09", result); // CPU efficient core 1
-        count += detectTemp(conn, "Tp0T", result); // CPU efficient core 2
+        case FF_TEMP_CPU_M1X:
+            count += detectTemp(conn, "Tp09", result); // CPU efficient core 1
+            count += detectTemp(conn, "Tp0T", result); // CPU efficient core 2
 
-        count += detectTemp(conn, "Tp01", result); // CPU performance core 1
-        count += detectTemp(conn, "Tp05", result); // CPU performance core 2
-        count += detectTemp(conn, "Tp0D", result); // CPU performance core 3
-        count += detectTemp(conn, "Tp0H", result); // CPU performance core 4
-        count += detectTemp(conn, "Tp0L", result); // CPU performance core 5
-        count += detectTemp(conn, "Tp0P", result); // CPU performance core 6
-        count += detectTemp(conn, "Tp0X", result); // CPU performance core 7
-        count += detectTemp(conn, "Tp0b", result); // CPU performance core 8
-        break;
+            count += detectTemp(conn, "Tp01", result); // CPU performance core 1
+            count += detectTemp(conn, "Tp05", result); // CPU performance core 2
+            count += detectTemp(conn, "Tp0D", result); // CPU performance core 3
+            count += detectTemp(conn, "Tp0H", result); // CPU performance core 4
+            count += detectTemp(conn, "Tp0L", result); // CPU performance core 5
+            count += detectTemp(conn, "Tp0P", result); // CPU performance core 6
+            count += detectTemp(conn, "Tp0X", result); // CPU performance core 7
+            count += detectTemp(conn, "Tp0b", result); // CPU performance core 8
+            break;
 
-    case FF_TEMP_CPU_M2X:
-        count += detectTemp(conn, "Tp1h", result); // CPU efficiency core 1
-        count += detectTemp(conn, "Tp1t", result); // CPU efficiency core 2
-        count += detectTemp(conn, "Tp1p", result); // CPU efficiency core 3
-        count += detectTemp(conn, "Tp1l", result); // CPU efficiency core 4
+        case FF_TEMP_CPU_M2X:
+            count += detectTemp(conn, "Tp1h", result); // CPU efficiency core 1
+            count += detectTemp(conn, "Tp1t", result); // CPU efficiency core 2
+            count += detectTemp(conn, "Tp1p", result); // CPU efficiency core 3
+            count += detectTemp(conn, "Tp1l", result); // CPU efficiency core 4
 
-        count += detectTemp(conn, "Tp01", result); // CPU performance core 1
-        count += detectTemp(conn, "Tp05", result); // CPU performance core 2
-        count += detectTemp(conn, "Tp09", result); // CPU performance core 3
-        count += detectTemp(conn, "Tp0D", result); // CPU performance core 4
-        count += detectTemp(conn, "Tp0X", result); // CPU performance core 5
-        count += detectTemp(conn, "Tp0b", result); // CPU performance core 6
-        count += detectTemp(conn, "Tp0f", result); // CPU performance core 7
-        count += detectTemp(conn, "Tp0j", result); // CPU performance core 8
-        break;
+            count += detectTemp(conn, "Tp01", result); // CPU performance core 1
+            count += detectTemp(conn, "Tp05", result); // CPU performance core 2
+            count += detectTemp(conn, "Tp09", result); // CPU performance core 3
+            count += detectTemp(conn, "Tp0D", result); // CPU performance core 4
+            count += detectTemp(conn, "Tp0X", result); // CPU performance core 5
+            count += detectTemp(conn, "Tp0b", result); // CPU performance core 6
+            count += detectTemp(conn, "Tp0f", result); // CPU performance core 7
+            count += detectTemp(conn, "Tp0j", result); // CPU performance core 8
+            break;
 
-    case FF_TEMP_CPU_M3X:
-        count += detectTemp(conn, "Te05", result); // CPU efficiency core 1
-        count += detectTemp(conn, "Te0L", result); // CPU efficiency core 2
-        count += detectTemp(conn, "Te0P", result); // CPU efficiency core 3
-        count += detectTemp(conn, "Te0S", result); // CPU efficiency core 4
-        count += detectTemp(conn, "Tf04", result); // CPU performance core 1
-        count += detectTemp(conn, "Tf09", result); // CPU performance core 2
-        count += detectTemp(conn, "Tf0A", result); // CPU performance core 3
-        count += detectTemp(conn, "Tf0B", result); // CPU performance core 4
-        count += detectTemp(conn, "Tf0D", result); // CPU performance core 5
-        count += detectTemp(conn, "Tf0E", result); // CPU performance core 6
-        count += detectTemp(conn, "Tf44", result); // CPU performance core 7
-        count += detectTemp(conn, "Tf49", result); // CPU performance core 8
-        count += detectTemp(conn, "Tf4A", result); // CPU performance core 9
-        count += detectTemp(conn, "Tf4B", result); // CPU performance core 10
-        count += detectTemp(conn, "Tf4D", result); // CPU performance core 11
-        count += detectTemp(conn, "Tf4E", result); // CPU performance core 12
-        break;
+        case FF_TEMP_CPU_M3X:
+            count += detectTemp(conn, "Te05", result); // CPU efficiency core 1
+            count += detectTemp(conn, "Te0L", result); // CPU efficiency core 2
+            count += detectTemp(conn, "Te0P", result); // CPU efficiency core 3
+            count += detectTemp(conn, "Te0S", result); // CPU efficiency core 4
+            count += detectTemp(conn, "Tf04", result); // CPU performance core 1
+            count += detectTemp(conn, "Tf09", result); // CPU performance core 2
+            count += detectTemp(conn, "Tf0A", result); // CPU performance core 3
+            count += detectTemp(conn, "Tf0B", result); // CPU performance core 4
+            count += detectTemp(conn, "Tf0D", result); // CPU performance core 5
+            count += detectTemp(conn, "Tf0E", result); // CPU performance core 6
+            count += detectTemp(conn, "Tf44", result); // CPU performance core 7
+            count += detectTemp(conn, "Tf49", result); // CPU performance core 8
+            count += detectTemp(conn, "Tf4A", result); // CPU performance core 9
+            count += detectTemp(conn, "Tf4B", result); // CPU performance core 10
+            count += detectTemp(conn, "Tf4D", result); // CPU performance core 11
+            count += detectTemp(conn, "Tf4E", result); // CPU performance core 12
+            break;
 
-    case FF_TEMP_CPU_M4X:
-        count += detectTemp(conn, "Te05", result); // CPU efficiency core 1
-        count += detectTemp(conn, "Te0S", result); // CPU efficiency core 2
-        count += detectTemp(conn, "Te09", result); // CPU efficiency core 3
-        count += detectTemp(conn, "Te0H", result); // CPU efficiency core 4
-        count += detectTemp(conn, "Tp01", result); // CPU performance core 1
-        count += detectTemp(conn, "Tp05", result); // CPU performance core 2
-        count += detectTemp(conn, "Tp09", result); // CPU performance core 3
-        count += detectTemp(conn, "Tp0D", result); // CPU performance core 4
-        count += detectTemp(conn, "Tp0V", result); // CPU performance core 5
-        count += detectTemp(conn, "Tp0Y", result); // CPU performance core 6
-        count += detectTemp(conn, "Tp0b", result); // CPU performance core 7
-        count += detectTemp(conn, "Tp0e", result); // CPU performance core 8
-        break;
+        case FF_TEMP_CPU_M4X:
+            count += detectTemp(conn, "Te05", result); // CPU efficiency core 1
+            count += detectTemp(conn, "Te0S", result); // CPU efficiency core 2
+            count += detectTemp(conn, "Te09", result); // CPU efficiency core 3
+            count += detectTemp(conn, "Te0H", result); // CPU efficiency core 4
+            count += detectTemp(conn, "Tp01", result); // CPU performance core 1
+            count += detectTemp(conn, "Tp05", result); // CPU performance core 2
+            count += detectTemp(conn, "Tp09", result); // CPU performance core 3
+            count += detectTemp(conn, "Tp0D", result); // CPU performance core 4
+            count += detectTemp(conn, "Tp0V", result); // CPU performance core 5
+            count += detectTemp(conn, "Tp0Y", result); // CPU performance core 6
+            count += detectTemp(conn, "Tp0b", result); // CPU performance core 7
+            count += detectTemp(conn, "Tp0e", result); // CPU performance core 8
+            break;
 
-    case FF_TEMP_GPU_INTEL:
-        count += detectTemp(conn, "TCGC", result); // GPU Intel Graphics
-        goto gpu_unknown;
+        case FF_TEMP_CPU_M5X:
+            count += detectTemp(conn, "Tp00", result); // CPU super core 1
+            count += detectTemp(conn, "Tp04", result); // CPU super core 2
+            count += detectTemp(conn, "Tp08", result); // CPU super core 3
+            count += detectTemp(conn, "Tp0C", result); // CPU super core 4
+            count += detectTemp(conn, "Tp0G", result); // CPU super core 5
+            count += detectTemp(conn, "Tp0K", result); // CPU super core 6
+            count += detectTemp(conn, "Tp0O", result); // CPU performance core 1
+            count += detectTemp(conn, "Tp0R", result); // CPU performance core 2
+            count += detectTemp(conn, "Tp0U", result); // CPU performance core 3
+            count += detectTemp(conn, "Tp0X", result); // CPU performance core 4
+            count += detectTemp(conn, "Tp0a", result); // CPU performance core 5
+            count += detectTemp(conn, "Tp0d", result); // CPU performance core 6
+            count += detectTemp(conn, "Tp0g", result); // CPU performance core 7
+            count += detectTemp(conn, "Tp0j", result); // CPU performance core 8
+            count += detectTemp(conn, "Tp0m", result); // CPU performance core 9
+            count += detectTemp(conn, "Tp0p", result); // CPU performance core 10
+            count += detectTemp(conn, "Tp0u", result); // CPU performance core 11
+            count += detectTemp(conn, "Tp0y", result); // CPU performance core 12
+            break;
 
-    case FF_TEMP_GPU_AMD:
-        count += detectTemp(conn, "TGDD", result); // GPU AMD Radeon
-        goto gpu_unknown;
+        case FF_TEMP_GPU_INTEL:
+            count += detectTemp(conn, "TCGC", result); // GPU Intel Graphics
+            goto gpu_unknown;
 
-    case FF_TEMP_GPU_UNKNOWN: // Nvidia?
-    gpu_unknown:
-        count += detectTemp(conn, "TG0D", result); // GPU diode
-        count += detectTemp(conn, "TG0P", result); // GPU proximity
-        break;
+        case FF_TEMP_GPU_AMD:
+            count += detectTemp(conn, "TGDD", result); // GPU AMD Radeon
+            goto gpu_unknown;
 
-    case FF_TEMP_GPU_M1X:
-        count += detectTemp(conn, "Tg05", result); // GPU 1
-        count += detectTemp(conn, "Tg0D", result); // GPU 2
-        count += detectTemp(conn, "Tg0L", result); // GPU 3
-        count += detectTemp(conn, "Tg0T", result); // GPU 4
-        break;
+        case FF_TEMP_GPU_UNKNOWN: // Nvidia?
+        gpu_unknown:
+            count += detectTemp(conn, "TG0D", result); // GPU diode
+            count += detectTemp(conn, "TG0P", result); // GPU proximity
+            break;
 
-    case FF_TEMP_GPU_M2X:
-        count += detectTemp(conn, "Tg0f", result); // GPU 1
-        count += detectTemp(conn, "Tg0j", result); // GPU 2
-        break;
+        case FF_TEMP_GPU_M1X:
+            count += detectTemp(conn, "Tg05", result); // GPU 1
+            count += detectTemp(conn, "Tg0D", result); // GPU 2
+            count += detectTemp(conn, "Tg0L", result); // GPU 3
+            count += detectTemp(conn, "Tg0T", result); // GPU 4
+            break;
 
-    case FF_TEMP_GPU_M3X:
-        count += detectTemp(conn, "Tf14", result); // GPU 1
-        count += detectTemp(conn, "Tf18", result); // GPU 2
-        count += detectTemp(conn, "Tf19", result); // GPU 3
-        count += detectTemp(conn, "Tf1A", result); // GPU 4
-        count += detectTemp(conn, "Tf24", result); // GPU 5
-        count += detectTemp(conn, "Tf28", result); // GPU 6
-        count += detectTemp(conn, "Tf29", result); // GPU 7
-        count += detectTemp(conn, "Tf2A", result); // GPU 8
-        break;
+        case FF_TEMP_GPU_M2X:
+            count += detectTemp(conn, "Tg0f", result); // GPU 1
+            count += detectTemp(conn, "Tg0j", result); // GPU 2
+            break;
 
-    case FF_TEMP_GPU_M4X:
-        count += detectTemp(conn, "Tg0G", result); // GPU 1 (Basic)
-        count += detectTemp(conn, "Tg0H", result); // GPU 2 (Basic)
-        count += detectTemp(conn, "Tg1U", result); // GPU 1 (Pro / Max)
-        count += detectTemp(conn, "Tg1k", result); // GPU 2 (Pro / Max)
-        count += detectTemp(conn, "Tg0K", result); // GPU 3
-        count += detectTemp(conn, "Tg0L", result); // GPU 4
-        count += detectTemp(conn, "Tg0d", result); // GPU 5
-        count += detectTemp(conn, "Tg0e", result); // GPU 6
-        count += detectTemp(conn, "Tg0j", result); // GPU 7
-        count += detectTemp(conn, "Tg0k", result); // GPU 8
-        break;
+        case FF_TEMP_GPU_M3X:
+            count += detectTemp(conn, "Tf14", result); // GPU 1
+            count += detectTemp(conn, "Tf18", result); // GPU 2
+            count += detectTemp(conn, "Tf19", result); // GPU 3
+            count += detectTemp(conn, "Tf1A", result); // GPU 4
+            count += detectTemp(conn, "Tf24", result); // GPU 5
+            count += detectTemp(conn, "Tf28", result); // GPU 6
+            count += detectTemp(conn, "Tf29", result); // GPU 7
+            count += detectTemp(conn, "Tf2A", result); // GPU 8
+            break;
 
-    case FF_TEMP_BATTERY:
-        count += detectTemp(conn, "TB1T", result); // Battery
-        count += detectTemp(conn, "TB2T", result); // Battery
-        break;
+        case FF_TEMP_GPU_M4X:
+            count += detectTemp(conn, "Tg0G", result); // GPU 1 (Basic)
+            count += detectTemp(conn, "Tg0H", result); // GPU 2 (Basic)
+            count += detectTemp(conn, "Tg1U", result); // GPU 1 (Pro / Max)
+            count += detectTemp(conn, "Tg1k", result); // GPU 2 (Pro / Max)
+            count += detectTemp(conn, "Tg0K", result); // GPU 3
+            count += detectTemp(conn, "Tg0L", result); // GPU 4
+            count += detectTemp(conn, "Tg0d", result); // GPU 5
+            count += detectTemp(conn, "Tg0e", result); // GPU 6
+            count += detectTemp(conn, "Tg0j", result); // GPU 7
+            count += detectTemp(conn, "Tg0k", result); // GPU 8
+            break;
 
-    case FF_TEMP_MEMORY:
-        count += detectTemp(conn, "Tm02", result); // Memory 1
-        count += detectTemp(conn, "Tm06", result); // Memory 2
-        count += detectTemp(conn, "Tm08", result); // Memory 3
-        count += detectTemp(conn, "Tm09", result); // Memory 4
-        break;
+        case FF_TEMP_GPU_M5X:
+            count += detectTemp(conn, "Tg0U", result); // GPU 1
+            count += detectTemp(conn, "Tg0X", result); // GPU 2
+            count += detectTemp(conn, "Tg0d", result); // GPU 3
+            count += detectTemp(conn, "Tg0g", result); // GPU 4
+            count += detectTemp(conn, "Tg0j", result); // GPU 5
+            count += detectTemp(conn, "Tg1Y", result); // GPU 6
+            count += detectTemp(conn, "Tg1c", result); // GPU 7
+            count += detectTemp(conn, "Tg1g", result); // GPU 8
+            break;
+
+        case FF_TEMP_BATTERY:
+            count += detectTemp(conn, "TB1T", result); // Battery
+            count += detectTemp(conn, "TB2T", result); // Battery
+            break;
+
+        case FF_TEMP_MEMORY:
+            count += detectTemp(conn, "Tm02", result); // Memory 1
+            count += detectTemp(conn, "Tm06", result); // Memory 2
+            count += detectTemp(conn, "Tm08", result); // Memory 3
+            count += detectTemp(conn, "Tm09", result); // Memory 4
+            count += detectTemp(conn, "Tm0p", result); // Memory Proximity 1 (M4)
+            count += detectTemp(conn, "Tm1p", result); // Memory Proximity 2 (M4)
+            count += detectTemp(conn, "Tm2p", result); // Memory Proximity 3 (M4)
+            break;
     }
 
-    if (count == 0)
+    if (count == 0) {
         return "No temperatures detected";
+    }
 
     *result /= count;
 
-    return NULL;
+    return nullptr;
 }

src/common/apple/smc_temps.h

@@ -2,20 +2,19 @@
 
 #include "fastfetch.h"
 
-typedef struct FFTempValue
-{
+typedef struct FFTempValue {
     FFstrbuf name;
     FFstrbuf deviceClass;
     double value;
 } FFTempValue;
 
-enum FFTempType
-{
+enum FFTempType: uint8_t {
     FF_TEMP_CPU_X64,
     FF_TEMP_CPU_M1X,
     FF_TEMP_CPU_M2X,
     FF_TEMP_CPU_M3X,
     FF_TEMP_CPU_M4X,
+    FF_TEMP_CPU_M5X,
 
     FF_TEMP_GPU_INTEL,
     FF_TEMP_GPU_AMD,
@@ -24,6 +23,7 @@ enum FFTempType
     FF_TEMP_GPU_M2X,
     FF_TEMP_GPU_M3X,
     FF_TEMP_GPU_M4X,
+    FF_TEMP_GPU_M5X,
 
     FF_TEMP_BATTERY,
 

src/common/apple/version.h

@@ -0,0 +1,5 @@
+#pragma once
+
+#include "fastfetch.h"
+
+bool ffGetAppNameAndVersion(const char* exePath, FFstrbuf* retName, FFstrbuf* retVersion);

src/common/apple/version.m

@@ -0,0 +1,43 @@
+#include "common/apple/version.h"
+#include "common/strutil.h"
+
+#import <Foundation/Foundation.h>
+
+#define APP_CONTENTS_MACOS ".app/Contents/MacOS"
+
+bool ffGetAppNameAndVersion(const char* exePath, FFstrbuf* retName, FFstrbuf* retVersion) {
+    char* lastSlash = strrchr(exePath, '/');
+    if (!lastSlash) {
+        return false;
+    }
+    if ((size_t) (lastSlash - exePath) > strlen("X" APP_CONTENTS_MACOS) && memcmp(lastSlash - strlen(APP_CONTENTS_MACOS), APP_CONTENTS_MACOS, strlen(APP_CONTENTS_MACOS)) != 0) {
+        return false;
+    }
+
+    lastSlash -= strlen("MacOS");
+    char infoPlistPath[PATH_MAX];
+    memcpy(infoPlistPath, exePath, (size_t) (lastSlash - exePath));
+    memcpy(infoPlistPath + (lastSlash - exePath), "Info.plist", sizeof("Info.plist")); // X.app/Contents/Info.plist
+    NSError* error;
+    NSDictionary* dict = [NSDictionary dictionaryWithContentsOfURL:[NSURL fileURLWithPath:@(infoPlistPath)]
+                                                             error:&error];
+    if (!dict) {
+        return false;
+    }
+
+    if (retName) {
+        NSString* bundleName = dict[@"CFBundleDisplayName"] ?: dict[@"CFBundleName"];
+        if (bundleName) {
+            ffStrbufSetS(retName, bundleName.UTF8String);
+        }
+    }
+
+    if (retVersion) {
+        NSString* bundleVersion = dict[@"CFBundleShortVersionString"];
+        if (bundleVersion) {
+            ffStrbufSetS(retVersion, bundleVersion.UTF8String);
+        }
+    }
+
+    return true;
+}

src/common/argType.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include "common/FFstrbuf.h"
+
+// For ffRegReadValue(s)
+// If length is 0, data will be allocated with malloc() and must be freed by the caller
+// Otherwise, data must point to a buffer of at least length bytes, and the actual length of the data will be written to length.
+typedef struct FFArgBuffer {
+    void* data;
+    uint32_t length;
+} FFArgBuffer;
+
+typedef enum FFArgType: uint8_t {
+    FF_ARG_TYPE_NULL = 0,
+    FF_ARG_TYPE_UINT,
+    FF_ARG_TYPE_UINT64,
+    FF_ARG_TYPE_UINT16,
+    FF_ARG_TYPE_UINT8,
+    FF_ARG_TYPE_INT,
+    FF_ARG_TYPE_STRING,
+    FF_ARG_TYPE_STRBUF,
+    FF_ARG_TYPE_FLOAT,
+    FF_ARG_TYPE_DOUBLE,
+    FF_ARG_TYPE_LIST,
+    FF_ARG_TYPE_BOOL,
+    FF_ARG_TYPE_BUFFER,
+} FFArgType;
+
+#define FF_ARG(variable, var_name) { _Generic((variable),                                   \
+        uint32_t: FF_ARG_TYPE_UINT,                                                         \
+        uint64_t: FF_ARG_TYPE_UINT64,                                                       \
+        uint16_t: FF_ARG_TYPE_UINT16,                                                       \
+        uint8_t: FF_ARG_TYPE_UINT8,                                                         \
+        int32_t: FF_ARG_TYPE_INT,                                                           \
+        char*: FF_ARG_TYPE_STRING,                                                          \
+        const char*: FF_ARG_TYPE_STRING,                                                    \
+        FFstrbuf: FF_ARG_TYPE_STRBUF,                                                       \
+        float: FF_ARG_TYPE_FLOAT,                                                           \
+        double: FF_ARG_TYPE_DOUBLE,                                                         \
+        FFlist: FF_ARG_TYPE_LIST,                                                           \
+        bool: FF_ARG_TYPE_BOOL,                                                             \
+        FFArgBuffer: FF_ARG_TYPE_BUFFER),                                                   \
+    _Generic((variable), char*: (variable), const char*: (variable), default: &(variable)), \
+    (var_name) }

src/common/arrutil.h

@@ -6,9 +6,9 @@
     #if !__cplusplus && FF_SUPPORTS_COUNT_OF
         #define ARRAY_SIZE(x) _Countof(x)
     #elif __has_builtin(__is_array)
-        #define ARRAY_SIZE(x) ({ static_assert(__is_array(__typeof__(x)), "Must be an array"); (uint32_t) (sizeof(x) / sizeof(*(x))); })
+        #define ARRAY_SIZE(x) ({ static_assert(__is_array(typeof(x)), "Must be an array"); (uint32_t) (sizeof(x) / sizeof(*(x))); })
     #elif __has_builtin(__builtin_types_compatible_p)
-        #define ARRAY_SIZE(x) ({ static_assert(!__builtin_types_compatible_p(__typeof__(x), __typeof__(&*(x))), "Must not be a pointer"); (uint32_t) (sizeof(x) / sizeof(*(x))); })
+        #define ARRAY_SIZE(x) ({ static_assert(!__builtin_types_compatible_p(typeof(x), typeof(&*(x))), "Must not be a pointer"); (uint32_t) (sizeof(x) / sizeof(*(x))); })
     #endif
 #endif
 #ifndef ARRAY_SIZE

src/common/base64.h

@@ -2,9 +2,8 @@
 
 #include "fastfetch.h"
 
-void ffBase64EncodeRaw(uint32_t size, const char *str, uint32_t *out_size, char *output);
-static inline FFstrbuf ffBase64EncodeStrbuf(const FFstrbuf* in)
-{
+void ffBase64EncodeRaw(uint32_t size, const char* str, uint32_t* out_size, char* output);
+static inline FFstrbuf ffBase64EncodeStrbuf(const FFstrbuf* in) {
     FFstrbuf out = ffStrbufCreateA(10 + in->length * 4 / 3);
     ffBase64EncodeRaw(in->length, in->chars, &out.length, out.chars);
     assert(out.length < out.allocated);
@@ -12,9 +11,8 @@ static inline FFstrbuf ffBase64EncodeStrbuf(const FFstrbuf* in)
     return out;
 }
 
-bool ffBase64DecodeRaw(uint32_t size, const char *str, uint32_t *out_size, char *output);
-static inline FFstrbuf ffBase64DecodeStrbuf(const FFstrbuf* in)
-{
+bool ffBase64DecodeRaw(uint32_t size, const char* str, uint32_t* out_size, char* output);
+static inline FFstrbuf ffBase64DecodeStrbuf(const FFstrbuf* in) {
     FFstrbuf out = ffStrbufCreateA(10 + in->length * 3 / 4);
     ffBase64DecodeRaw(in->length, in->chars, &out.length, out.chars);
     assert(out.length < out.allocated);

src/common/binary.h

@@ -11,7 +11,7 @@
  * @param userdata User-provided data passed to the callback function
  * @param minLength Minimum length of strings to extract
  *
- * @return NULL on success, error message on failure.
+ * @return nullptr on success, error message on failure.
  * @note This function won't return an error if no strings are found.
  *       Always check if strings are correctly extracted after this function all.
  */

src/common/color.h

@@ -10,6 +10,16 @@
 #define FF_COLOR_MODE_HIDDEN "8;"
 #define FF_COLOR_MODE_STRIKETHROUGH "9;"
 
+#define FF_COLOR_MODE_RESET_ "0"
+#define FF_COLOR_MODE_BOLD_ "1"
+#define FF_COLOR_MODE_DIM_ "2"
+#define FF_COLOR_MODE_ITALIC_ "3"
+#define FF_COLOR_MODE_UNDERLINE_ "4"
+#define FF_COLOR_MODE_BLINK_ "5"
+#define FF_COLOR_MODE_INVERSE_ "7"
+#define FF_COLOR_MODE_HIDDEN_ "8"
+#define FF_COLOR_MODE_STRIKETHROUGH_ "9"
+
 #define FF_COLOR_FG_BLACK "30"
 #define FF_COLOR_FG_RED "31"
 #define FF_COLOR_FG_GREEN "32"

src/common/dbus.h

@@ -1,13 +1,12 @@
 #pragma once
 
 #ifdef FF_HAVE_DBUS
-#include <dbus/dbus.h>
+    #include <dbus/dbus.h>
 
-#include "common/FFstrbuf.h"
-#include "common/library.h"
+    #include "common/FFstrbuf.h"
+    #include "common/library.h"
 
-typedef struct FFDBusLibrary
-{
+typedef struct FFDBusLibrary {
     FF_LIBRARY_SYMBOL(dbus_bus_get)
     FF_LIBRARY_SYMBOL(dbus_message_new_method_call)
     FF_LIBRARY_SYMBOL(dbus_message_append_args)
@@ -22,28 +21,26 @@ typedef struct FFDBusLibrary
     FF_LIBRARY_SYMBOL(dbus_connection_unref)
 } FFDBusLibrary;
 
-typedef struct FFDBusData
-{
+typedef struct FFDBusData {
     const FFDBusLibrary* lib;
     DBusConnection* connection;
 } FFDBusData;
 
-const char* ffDBusLoadData(DBusBusType busType, FFDBusData* data); //Returns an error message or NULL on success
+const char* ffDBusLoadData(DBusBusType busType, FFDBusData* data); // Returns an error message or nullptr on success
 bool ffDBusGetString(FFDBusData* dbus, DBusMessageIter* iter, FFstrbuf* result);
 bool ffDBusGetBool(FFDBusData* dbus, DBusMessageIter* iter, bool* result);
-bool ffDBusGetUint(FFDBusData* dbus, DBusMessageIter* iter, uint32_t* result);
+bool ffDBusGetUint(FFDBusData* dbus, DBusMessageIter* iter, uint64_t* result);
 DBusMessage* ffDBusGetMethodReply(FFDBusData* dbus, const char* busName, const char* objectPath, const char* interface, const char* method, const char* arg1, const char* arg2);
 DBusMessage* ffDBusGetProperty(FFDBusData* dbus, const char* busName, const char* objectPath, const char* interface, const char* property);
 bool ffDBusGetPropertyString(FFDBusData* dbus, const char* busName, const char* objectPath, const char* interface, const char* property, FFstrbuf* result);
-bool ffDBusGetInt(FFDBusData* dbus, DBusMessageIter* iter, int32_t* result);
-bool ffDBusGetPropertyUint(FFDBusData* dbus, const char* busName, const char* objectPath, const char* interface, const char* property, uint32_t* result);
+bool ffDBusGetInt(FFDBusData* dbus, DBusMessageIter* iter, int64_t* result);
+bool ffDBusGetPropertyUint(FFDBusData* dbus, const char* busName, const char* objectPath, const char* interface, const char* property, uint64_t* result);
 void ffDBusDestroyData(FFDBusData* data);
 
-static inline DBusMessage* ffDBusGetAllProperties(FFDBusData* dbus, const char* busName, const char* objectPath, const char* interface)
-{
-    return ffDBusGetMethodReply(dbus, busName, objectPath, "org.freedesktop.DBus.Properties", "GetAll", interface, NULL);
+static inline DBusMessage* ffDBusGetAllProperties(FFDBusData* dbus, const char* busName, const char* objectPath, const char* interface) {
+    return ffDBusGetMethodReply(dbus, busName, objectPath, "org.freedesktop.DBus.Properties", "GetAll", interface, nullptr);
 }
 
-#define FF_DBUS_AUTO_DESTROY_DATA __attribute__((__cleanup__(ffDBusDestroyData)))
+    #define FF_DBUS_AUTO_DESTROY_DATA [[gnu::cleanup(ffDBusDestroyData)]]
 
 #endif // FF_HAVE_DBUS

src/common/debug.h

@@ -3,31 +3,36 @@
 #include "fastfetch.h"
 #include "common/time.h"
 
-static inline const char* ffFindFileName(const char* file)
-{
+static inline const char* ffFindFileName(const char* file) {
     const char* lastSlash = __builtin_strrchr(file, '/');
-    #ifdef _WIN32
-    if (lastSlash == NULL)
+#ifdef _WIN32
+    if (lastSlash == nullptr) {
         lastSlash = __builtin_strrchr(file, '\\');
-    #endif
-    if (lastSlash != NULL)
+    }
+#endif
+    if (lastSlash != nullptr) {
         return lastSlash + 1;
+    }
     return file;
 }
 
 #ifndef NDEBUG
-    #define FF_DEBUG_PRINT(file_, line_, format_, ...) \
-        do { \
-            if (instance.config.display.debugMode) \
+    #define FF_DEBUG_PRINT(file_, line_, format_, ...)                                                                                      \
+        do {                                                                                                                                \
+            if (instance.config.display.debugMode)                                                                                          \
                 fprintf(stderr, "[%s%4d, %s] " format_ "\n", ffFindFileName(file_), line_, ffTimeToTimeStr(ffTimeGetNow()), ##__VA_ARGS__); \
         } while (0)
 #else
     #define FF_DEBUG_PRINT(file_, line_, format_, ...) \
-        do { } while (0)
+        do {                                           \
+        } while (0)
 #endif
 
 #define FF_DEBUG(format, ...) FF_DEBUG_PRINT(__FILE__, __LINE__, format, ##__VA_ARGS__)
 
 #if _WIN32
-const char* ffDebugWin32Error(unsigned long errorCode);
+const char* ffDebugWin32Error(DWORD errorCode);
+const char* ffDebugNtStatus(NTSTATUS status);
+const char* ffDebugConfigRet(unsigned long /*CONFIGRET*/ ret);
+const char* ffDebugHResult(HRESULT hr);
 #endif

src/common/edidHelper.h

@@ -8,5 +8,7 @@ bool ffEdidGetName(const uint8_t edid[128], FFstrbuf* name);
 void ffEdidGetPreferredResolutionAndRefreshRate(const uint8_t edid[128], uint32_t* width, uint32_t* height, double* refreshRate);
 void ffEdidGetPhysicalResolution(const uint8_t edid[128], uint32_t* width, uint32_t* height);
 void ffEdidGetPhysicalSize(const uint8_t edid[128], uint32_t* width, uint32_t* height); // in mm
-void ffEdidGetSerialAndManufactureDate(const uint8_t edid[128], uint32_t* serial, uint16_t* year, uint16_t* week);
+void ffEdidGetManufactureDate(const uint8_t edid[128], uint16_t* year, uint16_t* week);
+bool ffEdidGetSerial(const uint8_t edid[128], FFstrbuf* result);
 bool ffEdidGetHdrCompatible(const uint8_t* edid, uint32_t length);
+bool ffEdidIsValid(const uint8_t edid[128], uint32_t length);

src/common/endian.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <stdint.h>
+
+#if __BIG_ENDIAN__
+    #define FF_READ_LE(x) _Generic((x), \
+        uint16_t: __builtin_bswap16(x), \
+        uint32_t: __builtin_bswap32(x), \
+        uint64_t: __builtin_bswap64(x))
+    #define FF_READ_BE(x) (x)
+#else
+    #define FF_READ_LE(x) (x)
+    #define FF_READ_BE(x) _Generic((x), \
+        uint16_t: __builtin_bswap16(x), \
+        uint32_t: __builtin_bswap32(x), \
+        uint64_t: __builtin_bswap64(x))
+#endif

src/common/ffdata.h

@@ -2,8 +2,7 @@
 
 #include "common/FFstrbuf.h"
 
-typedef enum __attribute__((__packed__)) FFDataResultDocType
-{
+typedef enum FFDataResultDocType: uint8_t {
     FF_RESULT_DOC_TYPE_DEFAULT = 0,
     FF_RESULT_DOC_TYPE_JSON,
     FF_RESULT_DOC_TYPE_CONFIG,
@@ -12,13 +11,13 @@ typedef enum __attribute__((__packed__)) FFDataResultDocType
 
 // FFdata aggregates configuration, generation parameters, and output state used by fastfetch.
 // It holds the parsed configuration document, a mutable JSON document for results, and related metadata.
-typedef struct FFdata
-{
-    yyjson_doc* configDoc; // Parsed JSON configuration document
-    yyjson_mut_doc* resultDoc; // Mutable JSON document for storing results
-    FFstrbuf structure; // Custom output structure from command line
-    FFstrbuf structureDisabled; // Disabled modules in the output structure from command line
-    FFstrbuf genConfigPath; // Path to generate configuration file
+typedef struct FFdata {
+    yyjson_doc* configDoc;       // Parsed JSON configuration document
+    yyjson_mut_doc* resultDoc;   // Mutable JSON document for storing results
+    FFstrbuf structure;          // Custom output structure from command line
+    FFstrbuf structureDisabled;  // Disabled modules in the output structure from command line
+    FFstrbuf genConfigPath;      // Path to generate configuration file
     FFDataResultDocType docType; // Type of result document
     bool configLoaded;
+    bool genConfigInteractive; // `--gen-config` entered the interactive CUI
 } FFdata;

src/common/font.h

@@ -3,8 +3,7 @@
 #include "common/FFstrbuf.h"
 #include "common/FFlist.h"
 
-typedef struct FFfont
-{
+typedef struct FFfont {
     FFstrbuf pretty;
     FFstrbuf name;
     FFstrbuf size;
@@ -21,7 +20,6 @@ void ffFontInitMoveValues(FFfont* font, FFstrbuf* name, FFstrbuf* size, FFstrbuf
 void ffFontInitWithSpace(FFfont* font, const char* rawName);
 void ffFontDestroy(FFfont* font);
 
-static inline void ffFontInitCopy(FFfont* font, const char* name)
-{
-    ffFontInitValues(font, name, NULL);
+static inline void ffFontInitCopy(FFfont* font, const char* name) {
+    ffFontInitValues(font, name, nullptr);
 }

src/common/format.h

@@ -1,46 +1,14 @@
 #pragma once
 
-#include "common/FFstrbuf.h"
+#include "common/argType.h"
 
-typedef enum __attribute__((__packed__)) FFformatArgType
-{
-    FF_FORMAT_ARG_TYPE_NULL = 0,
-    FF_FORMAT_ARG_TYPE_UINT,
-    FF_FORMAT_ARG_TYPE_UINT64,
-    FF_FORMAT_ARG_TYPE_UINT16,
-    FF_FORMAT_ARG_TYPE_UINT8,
-    FF_FORMAT_ARG_TYPE_INT,
-    FF_FORMAT_ARG_TYPE_STRING,
-    FF_FORMAT_ARG_TYPE_STRBUF,
-    FF_FORMAT_ARG_TYPE_FLOAT,
-    FF_FORMAT_ARG_TYPE_DOUBLE,
-    FF_FORMAT_ARG_TYPE_LIST,
-    FF_FORMAT_ARG_TYPE_BOOL
-} FFformatArgType;
-
-#define FF_FORMAT_ARG(variable, var_name) { _Generic((variable), \
-        uint32_t: FF_FORMAT_ARG_TYPE_UINT, \
-        uint64_t: FF_FORMAT_ARG_TYPE_UINT64, \
-        uint16_t: FF_FORMAT_ARG_TYPE_UINT16, \
-        uint8_t: FF_FORMAT_ARG_TYPE_UINT8, \
-        int32_t: FF_FORMAT_ARG_TYPE_INT, \
-        char*: FF_FORMAT_ARG_TYPE_STRING, \
-        const char*: FF_FORMAT_ARG_TYPE_STRING, \
-        FFstrbuf: FF_FORMAT_ARG_TYPE_STRBUF, \
-        float: FF_FORMAT_ARG_TYPE_FLOAT, \
-        double: FF_FORMAT_ARG_TYPE_DOUBLE, \
-        FFlist: FF_FORMAT_ARG_TYPE_LIST, \
-        bool: FF_FORMAT_ARG_TYPE_BOOL \
-    ), _Generic((variable), char*: (variable), const char*: (variable), default: &(variable) ), (var_name) }
-
-typedef struct FFformatarg
-{
-    FFformatArgType type;
+typedef struct FFformatarg {
+    FFArgType type;
     const void* value;
     const char* name; // argument name, must start with an alphabet
 } FFformatarg;
 
 void ffFormatAppendFormatArg(FFstrbuf* buffer, const FFformatarg* formatarg);
-void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t numArgs, const FFformatarg* arguments);
+bool ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t numArgs, const FFformatarg* arguments);
 #define FF_PARSE_FORMAT_STRING_CHECKED(buffer, formatstr, arguments) \
     ffParseFormatString((buffer), (formatstr), sizeof(arguments) / sizeof(*arguments), (arguments));

src/common/genconfig.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include "common/ffdata.h"
+
+// Runs the interactive config generation CUI.
+//
+// On success (the user saved the config), it sets `data->structure` to the user chosen
+// module structure and `instance.config.logo.type` to the user chosen logo type, creates
+// the result document and returns true. The caller is expected to call `writeConfigFile`.
+// Returns false if the user quits without saving.
+bool ffGenConfigInteractive(FFdata* data);

src/common/haiku/version.cpp

@@ -5,20 +5,22 @@ extern "C" {
 #include <File.h>
 #include <AppFileInfo.h>
 
-bool ffGetFileVersion(const char* filePath, FFstrbuf* version)
-{
+bool ffGetFileVersion(const char* filePath, FFstrbuf* version) {
     BFile f(filePath, B_READ_ONLY);
-    if (f.InitCheck() != B_OK)
+    if (f.InitCheck() != B_OK) {
         return false;
+    }
 
     BAppFileInfo fileInfo(&f);
-    if (f.InitCheck() != B_OK)
+    if (f.InitCheck() != B_OK) {
         return false;
+    }
 
     version_info info;
-    if (fileInfo.GetVersionInfo(&info, B_SYSTEM_VERSION_KIND) != B_OK)
+    if (fileInfo.GetVersionInfo(&info, B_SYSTEM_VERSION_KIND) != B_OK) {
         return false;
+    }
 
-    ffStrbufSetF(version, "%d.%d.%d", (int)info.major, (int)info.middle, (int)info.minor);
+    ffStrbufSetF(version, "%d.%d.%d", (int) info.major, (int) info.middle, (int) info.minor);
     return true;
 }

src/common/impl/FFPlatform.c

@@ -1,14 +1,13 @@
 #include "FFPlatform_private.h"
-#include "common/stringUtils.h"
+#include "common/strutil.h"
 #include "common/io.h"
 #include "detection/version/version.h"
 
-void ffPlatformInit(FFPlatform* platform)
-{
+void ffPlatformInit(FFPlatform* platform) {
     ffStrbufInit(&platform->homeDir);
     ffStrbufInit(&platform->cacheDir);
-    ffListInit(&platform->configDirs, sizeof(FFstrbuf));
-    ffListInit(&platform->dataDirs, sizeof(FFstrbuf));
+    ffListInit(&platform->configDirs);
+    ffListInit(&platform->dataDirs);
     ffStrbufInit(&platform->exePath);
     ffStrbufInit(&platform->cwd);
 
@@ -17,9 +16,10 @@ void ffPlatformInit(FFPlatform* platform)
     ffStrbufInit(&platform->hostName);
     ffStrbufInit(&platform->userShell);
 
-    #ifdef _WIN32
+#ifdef _WIN32
     ffStrbufInit(&platform->sid);
-    #endif
+    platform->initCP = 0;
+#endif
 
     FFPlatformSysinfo* info = &platform->sysinfo;
 
@@ -27,27 +27,31 @@ void ffPlatformInit(FFPlatform* platform)
     ffStrbufInit(&info->release);
     ffStrbufInit(&info->version);
     ffStrbufInit(&info->architecture);
+    info->pageSize = 0;
 
     ffPlatformInitImpl(platform);
 
-    if(info->name.length == 0)
+    if (info->name.length == 0) {
         ffStrbufSetStatic(&info->name, ffVersionResult.sysName);
+    }
 
-    if(info->architecture.length == 0)
+    if (info->architecture.length == 0) {
         ffStrbufSetStatic(&info->architecture, ffVersionResult.architecture);
+    }
 }
 
-void ffPlatformDestroy(FFPlatform* platform)
-{
+void ffPlatformDestroy(FFPlatform* platform) {
     ffStrbufDestroy(&platform->homeDir);
     ffStrbufDestroy(&platform->cacheDir);
 
-    FF_LIST_FOR_EACH(FFstrbuf, dir, platform->configDirs)
+    FF_LIST_FOR_EACH (FFstrbuf, dir, platform->configDirs) {
         ffStrbufDestroy(dir);
+    }
     ffListDestroy(&platform->configDirs);
 
-    FF_LIST_FOR_EACH(FFstrbuf, dir, platform->dataDirs)
+    FF_LIST_FOR_EACH (FFstrbuf, dir, platform->dataDirs) {
         ffStrbufDestroy(dir);
+    }
     ffListDestroy(&platform->dataDirs);
     ffStrbufDestroy(&platform->exePath);
     ffStrbufDestroy(&platform->cwd);
@@ -57,9 +61,9 @@ void ffPlatformDestroy(FFPlatform* platform)
     ffStrbufDestroy(&platform->userShell);
     ffStrbufDestroy(&platform->fullUserName);
 
-    #ifdef _WIN32
+#ifdef _WIN32
     ffStrbufDestroy(&platform->sid);
-    #endif
+#endif
 
     FFPlatformSysinfo* info = &platform->sysinfo;
     ffStrbufDestroy(&info->architecture);
@@ -68,23 +72,24 @@ void ffPlatformDestroy(FFPlatform* platform)
     ffStrbufDestroy(&info->version);
 }
 
-void ffPlatformPathAddAbsolute(FFlist* dirs, const char* path)
-{
-    if (!ffPathExists(path, FF_PATHTYPE_DIRECTORY))
+void ffPlatformPathAddAbsolute(FFlist* dirs, const char* path) {
+    if (!ffPathExists(path, FF_PATHTYPE_DIRECTORY)) {
         return;
+    }
 
     FF_STRBUF_AUTO_DESTROY buffer = ffStrbufCreateS(path);
     ffStrbufEnsureEndsWithC(&buffer, '/');
-    if (!ffListContains(dirs, &buffer, (void*) ffStrbufEqual))
-        ffStrbufInitMove((FFstrbuf*) ffListAdd(dirs), &buffer);
+    if (!FF_LIST_CONTAINS(*dirs, &buffer, ffStrbufEqual)) {
+        ffStrbufInitMove(FF_LIST_ADD(FFstrbuf, *dirs), &buffer);
+    }
 }
 
-void ffPlatformPathAddHome(FFlist* dirs, const FFPlatform* platform, const char* suffix)
-{
+void ffPlatformPathAddHome(FFlist* dirs, const FFPlatform* platform, const char* suffix) {
     FF_STRBUF_AUTO_DESTROY buffer = ffStrbufCreateA(64);
     ffStrbufAppend(&buffer, &platform->homeDir);
     ffStrbufAppendS(&buffer, suffix);
     ffStrbufEnsureEndsWithC(&buffer, '/');
-    if (ffPathExists(buffer.chars, FF_PATHTYPE_DIRECTORY) && !ffListContains(dirs, &buffer, (void*) ffStrbufEqual))
-        ffStrbufInitMove((FFstrbuf*) ffListAdd(dirs), &buffer);
+    if (ffPathExists(buffer.chars, FF_PATHTYPE_DIRECTORY) && !FF_LIST_CONTAINS(*dirs, &buffer, ffStrbufEqual)) {
+        ffStrbufInitMove(FF_LIST_ADD(FFstrbuf, *dirs), &buffer);
+    }
 }

src/common/impl/FFPlatform_unix.c

@@ -1,9 +1,9 @@
 #include "FFPlatform_private.h"
 #include "common/FFstrbuf.h"
-#include "common/arrayUtils.h"
-#include "common/stringUtils.h"
+#include "common/arrutil.h"
+#include "common/strutil.h"
 #include "common/io.h"
-#include "fastfetch_config.h"
+#include "common/path.h"
 
 #include <unistd.h>
 #include <pwd.h>
@@ -18,6 +18,7 @@
     #include <sys/sysctl.h>
 #elif defined(__OpenBSD__)
     #include <sys/sysctl.h>
+    #include <sys/stat.h>
     #include <kvm.h>
     #include "common/path.h"
 #elif defined(__HAIKU__)
@@ -25,154 +26,148 @@
     #include <OS.h>
 #endif
 
-static void getExePath(FFPlatform* platform)
-{
+static void getExePath(FFPlatform* platform) {
     char exePath[PATH_MAX];
-    #if defined(__linux__) || defined (__GNU__)
-        ssize_t exePathLen = readlink("/proc/self/exe", exePath, sizeof(exePath) - 1);
-        if (exePathLen >= 0)
-            exePath[exePathLen] = '\0';
-    #elif defined(__APPLE__)
-        uint32_t exePathLen = sizeof(exePath);
-        if (_NSGetExecutablePath(exePath, &exePathLen) == 0)
-            exePathLen = (uint32_t) strlen(exePath);
-        else
-            exePathLen = 0;
-    #elif defined(__FreeBSD__) || defined(__NetBSD__)
-        size_t exePathLen = sizeof(exePath);
-        if(sysctl(
-            (int[]){CTL_KERN,
-            #ifdef __FreeBSD__
-                KERN_PROC, KERN_PROC_PATHNAME, (pid_t) platform->pid
-            #else
-                KERN_PROC_ARGS, platform->pid, KERN_PROC_PATHNAME
-            #endif
-            }, 4,
-            exePath, &exePathLen,
-            NULL, 0
-        ) < 0)
-            exePathLen = 0;
-        else
-            exePathLen--; // remove terminating NUL
-    #elif defined(__OpenBSD__)
-        // OpenBSD doesn't have a reliable way to get the executable path.
-        // Current implementation uses argv[0], which can be easily spoofed.
-        // See #2195
-        size_t exePathLen = 0;
-        kvm_t* kd = kvm_openfiles(NULL, NULL, NULL, KVM_NO_FILES, NULL);
-        if (kd)
-        {
-            int kpCount;
-            struct kinfo_proc* kp = kvm_getprocs(kd, KERN_PROC_PID, (pid_t) platform->pid, sizeof(*kp), &kpCount);
-            if (kp && kpCount == 1)
-            {
-                char** argv = kvm_getargv(kd, kp, 0);
-                if (argv && argv[0])
-                {
-                    char* arg0 = argv[0];
-                    if (arg0[0])
+#if defined(__linux__) || defined(__GNU__)
+    ssize_t exePathLen = readlink("/proc/self/exe", exePath, sizeof(exePath) - 1);
+    if (exePathLen > 0) {
+        exePath[exePathLen] = '\0';
+    }
+#elif defined(__APPLE__)
+    uint32_t exePathLen = sizeof(exePath);
+    if (_NSGetExecutablePath(exePath, &exePathLen) == 0) {
+        exePathLen = (uint32_t) strlen(exePath);
+    } else {
+        exePathLen = 0;
+    }
+#elif defined(__FreeBSD__) || defined(__NetBSD__)
+    size_t exePathLen = sizeof(exePath);
+    if (sysctl(
+            (int[]) { CTL_KERN,
+    #ifdef __FreeBSD__
+                KERN_PROC,
+                KERN_PROC_PATHNAME,
+                (pid_t) platform->pid
+    #else
+                KERN_PROC_ARGS,
+                (pid_t) platform->pid,
+                KERN_PROC_PATHNAME
+    #endif
+            },
+            4,
+            exePath,
+            &exePathLen,
+            nullptr,
+            0) < 0)
+        exePathLen = 0;
+    else {
+        exePathLen--; // remove terminating NUL
+    }
+#elif defined(__OpenBSD__)
+    // OpenBSD doesn't have a reliable way to get the executable path.
+    // Current implementation uses argv[0], which can be easily spoofed.
+    // See #2195
+    size_t exePathLen = 0;
+    kvm_t* kd = kvm_openfiles(nullptr, nullptr, nullptr, KVM_NO_FILES, nullptr);
+    if (kd) {
+        int kpCount;
+        struct kinfo_proc* kp = kvm_getprocs(kd, KERN_PROC_PID, (pid_t) platform->pid, sizeof(*kp), &kpCount);
+        if (kp && kpCount == 1) {
+            char** argv = kvm_getargv(kd, kp, 0);
+            if (argv && argv[0]) {
+                char* arg0 = argv[0];
+                if (arg0[0]) {
+                    if (strchr(arg0, '/') != nullptr) // likely a path (absolute or relative)
                     {
-                        if (strchr(arg0, '/') != NULL) // likely a path (absolute or relative)
-                        {
-                            exePathLen = strlen(arg0);
-                            if (exePathLen < ARRAY_SIZE(exePath))
-                            {
-                                memcpy(exePath, arg0, exePathLen);
-                                exePath[exePathLen] = '\0';
-                            }
-                            else
-                                exePathLen = 0;
+                        exePathLen = strlen(arg0);
+                        if (exePathLen < ARRAY_SIZE(exePath)) {
+                            memcpy(exePath, arg0, exePathLen);
+                            exePath[exePathLen] = '\0';
+                        } else {
+                            exePathLen = 0;
                         }
-                        else
-                        {
-                            FF_STRBUF_AUTO_DESTROY tmpPath = ffStrbufCreate();
-                            if (ffFindExecutableInPath(arg0, &tmpPath) == NULL && tmpPath.length < ARRAY_SIZE(exePath))
-                            {
-                                memcpy(exePath, tmpPath.chars, tmpPath.length + 1);
-                                exePathLen = tmpPath.length;
-                            }
+                    } else {
+                        FF_STRBUF_AUTO_DESTROY tmpPath = ffStrbufCreate();
+                        if (ffFindExecutableInPath(arg0, &tmpPath) == nullptr && tmpPath.length < ARRAY_SIZE(exePath)) {
+                            memcpy(exePath, tmpPath.chars, tmpPath.length + 1);
+                            exePathLen = tmpPath.length;
                         }
+                    }
 
-                        if (exePathLen > 0)
-                        {
-                            struct stat st;
-                            if (stat(exePath, &st) == 0 && S_ISREG(st.st_mode))
-                            {
-                                int cntp;
-                                struct kinfo_file* kf = kvm_getfiles(kd, KERN_FILE_BYPID, platform->pid, sizeof(*kf), &cntp);
-                                if (kf)
-                                {
-                                    int i;
-                                    for (i = 0; i < cntp; i++)
-                                    {
-                                        if (kf[i].fd_fd == KERN_FILE_TEXT)
-                                        {
-                                            // KERN_FILE_TEXT is the executable file, not a shared library, and should be unique in the list.
-                                            if (st.st_dev != (dev_t)kf[i].va_fsid || st.st_ino != (ino_t)kf[i].va_fileid)
-                                                i = -1;
-                                            break;
+                    if (exePathLen > 0) {
+                        struct stat st;
+                        if (stat(exePath, &st) == 0 && S_ISREG(st.st_mode)) {
+                            int cntp;
+                            struct kinfo_file* kf = kvm_getfiles(kd, KERN_FILE_BYPID, (pid_t) platform->pid, sizeof(*kf), &cntp);
+                            if (kf) {
+                                int i;
+                                for (i = 0; i < cntp; i++) {
+                                    if (kf[i].fd_fd == KERN_FILE_TEXT) {
+                                        // KERN_FILE_TEXT is the executable file, not a shared library, and should be unique in the list.
+                                        if (st.st_dev != (dev_t) kf[i].va_fsid || st.st_ino != (ino_t) kf[i].va_fileid) {
+                                            i = -1;
                                         }
+                                        break;
                                     }
-                                    if (i < 0)
-                                        exePathLen = 0;
                                 }
-                                else
-                                {
-                                    // If we can't get the list of open files, we can't verify that the file is actually the executable
-                                    // Assume it is
+                                if (i < 0) {
+                                    exePathLen = 0;
                                 }
+                            } else {
+                                // If we can't get the list of open files, we can't verify that the file is actually the executable
+                                // Assume it is
                             }
-                            else
-                                exePathLen = 0;
+                        } else {
+                            exePathLen = 0;
                         }
                     }
                 }
             }
-            kvm_close(kd);
         }
-    #elif defined(__sun)
-        ssize_t exePathLen = readlink("/proc/self/path/a.out", exePath, sizeof(exePath) - 1);
-        if (exePathLen >= 0)
-            exePath[exePathLen] = '\0';
-    #elif defined(__HAIKU__)
-        size_t exePathLen = 0;
-        image_info info;
-        int32 cookie = 0;
+        kvm_close(kd);
+    }
+#elif defined(__sun)
+    ssize_t exePathLen = readlink("/proc/self/path/a.out", exePath, sizeof(exePath) - 1);
+    if (exePathLen > 0) {
+        exePath[exePathLen] = '\0';
+    }
+#elif defined(__HAIKU__)
+    size_t exePathLen = 0;
+    image_info info;
+    int32 cookie = 0;
 
-        while (get_next_image_info(B_CURRENT_TEAM, &cookie, &info) == B_OK) {
-            if (info.type == B_APP_IMAGE) {
-                exePathLen = strlcpy(exePath, info.name, sizeof(exePath));
-                break;
-            }
+    while (get_next_image_info(B_CURRENT_TEAM, &cookie, &info) == B_OK) {
+        if (info.type == B_APP_IMAGE) {
+            exePathLen = strlcpy(exePath, info.name, sizeof(exePath));
+            break;
         }
-    #endif
-    if (exePathLen > 0)
-    {
+    }
+#endif
+    if (exePathLen > 0) {
         ffStrbufEnsureFree(&platform->exePath, PATH_MAX);
-        if (realpath(exePath, platform->exePath.chars))
+        if (realpath(exePath, platform->exePath.chars)) {
             ffStrbufRecalculateLength(&platform->exePath);
-        else
+        } else {
             ffStrbufSetNS(&platform->exePath, (uint32_t) exePathLen, exePath);
+        }
     }
 }
 
-static void platformPathAddEnv(FFlist* dirs, const char* env)
-{
+static void platformPathAddEnv(FFlist* dirs, const char* env) {
     const char* envValue = getenv(env);
-    if(!ffStrSet(envValue))
+    if (!ffStrSet(envValue)) {
         return;
+    }
 
     FF_STRBUF_AUTO_DESTROY value = ffStrbufCreateA(64);
     ffStrbufAppendS(&value, envValue);
 
     uint32_t startIndex = 0;
-    while (startIndex < value.length)
-    {
+    while (startIndex < value.length) {
         uint32_t colonIndex = ffStrbufNextIndexC(&value, startIndex, ':');
         value.chars[colonIndex] = '\0';
 
-        if(!ffStrSet(value.chars + startIndex))
-        {
+        if (!ffStrSet(value.chars + startIndex)) {
             startIndex = colonIndex + 1;
             continue;
         }
@@ -183,61 +178,53 @@ static void platformPathAddEnv(FFlist* dirs, const char* env)
     }
 }
 
-static void getHomeDir(FFPlatform* platform, const struct passwd* pwd)
-{
+static void getHomeDir(FFPlatform* platform, const struct passwd* pwd) {
     const char* home = pwd ? pwd->pw_dir : getenv("HOME");
     ffStrbufAppendS(&platform->homeDir, home);
     ffStrbufEnsureEndsWithC(&platform->homeDir, '/');
 }
 
-static void getCacheDir(FFPlatform* platform)
-{
+static void getCacheDir(FFPlatform* platform) {
     const char* cache = getenv("XDG_CACHE_HOME");
-    if(ffStrSet(cache))
-    {
+    if (ffStrSet(cache)) {
         ffStrbufAppendS(&platform->cacheDir, cache);
         ffStrbufEnsureEndsWithC(&platform->cacheDir, '/');
-    }
-    else
-    {
+    } else {
         ffStrbufAppend(&platform->cacheDir, &platform->homeDir);
         ffStrbufAppendS(&platform->cacheDir, ".cache/");
     }
 }
 
-static void getConfigDirs(FFPlatform* platform)
-{
+static void getConfigDirs(FFPlatform* platform) {
     // Always make sure `${XDG_CONFIG_HOME:-$HOME/.config}` is the first entry
     platformPathAddEnv(&platform->configDirs, "XDG_CONFIG_HOME");
     ffPlatformPathAddHome(&platform->configDirs, platform, ".config/");
 
-    #if defined(__APPLE__)
-        ffPlatformPathAddHome(&platform->configDirs, platform, "Library/Preferences/");
-        ffPlatformPathAddHome(&platform->configDirs, platform, "Library/Application Support/");
-    #endif
-    #if defined(__HAIKU__)
-        ffPlatformPathAddHome(&platform->configDirs, platform, "config/settings/");
-    #endif
+#if defined(__APPLE__)
+    ffPlatformPathAddHome(&platform->configDirs, platform, "Library/Preferences/");
+    ffPlatformPathAddHome(&platform->configDirs, platform, "Library/Application Support/");
+#endif
+#if defined(__HAIKU__)
+    ffPlatformPathAddHome(&platform->configDirs, platform, "config/settings/");
+#endif
 
     ffPlatformPathAddHome(&platform->configDirs, platform, "");
     platformPathAddEnv(&platform->configDirs, "XDG_CONFIG_DIRS");
 
-    #if !defined(__APPLE__)
-        ffPlatformPathAddAbsolute(&platform->configDirs, FASTFETCH_TARGET_DIR_ETC "/xdg/");
-    #endif
+#if !defined(__APPLE__)
+    ffPlatformPathAddAbsolute(&platform->configDirs, FASTFETCH_TARGET_DIR_ETC "/xdg/");
+#endif
 
     ffPlatformPathAddAbsolute(&platform->configDirs, FASTFETCH_TARGET_DIR_ETC "/");
     ffPlatformPathAddAbsolute(&platform->configDirs, FASTFETCH_TARGET_DIR_INSTALL_SYSCONF "/");
 }
 
-static void getDataDirs(FFPlatform* platform)
-{
+static void getDataDirs(FFPlatform* platform) {
     platformPathAddEnv(&platform->dataDirs, "XDG_DATA_HOME");
     ffPlatformPathAddHome(&platform->dataDirs, platform, ".local/share/");
 
     // Add ${currentExePath}/../share
-    if (platform->exePath.length > 0)
-    {
+    if (platform->exePath.length > 0) {
         FF_STRBUF_AUTO_DESTROY path = ffStrbufCreateCopy(&platform->exePath);
         ffStrbufSubstrBeforeLastC(&path, '/');
         ffStrbufSubstrBeforeLastC(&path, '/');
@@ -245,87 +232,79 @@ static void getDataDirs(FFPlatform* platform)
         ffPlatformPathAddAbsolute(&platform->dataDirs, path.chars);
     }
 
-    #ifdef __APPLE__
-        ffPlatformPathAddHome(&platform->dataDirs, platform, "Library/Application Support/");
-    #endif
+#ifdef __APPLE__
+    ffPlatformPathAddHome(&platform->dataDirs, platform, "Library/Application Support/");
+#endif
 
     ffPlatformPathAddHome(&platform->dataDirs, platform, "");
     platformPathAddEnv(&platform->dataDirs, "XDG_DATA_DIRS");
-#ifdef _PATH_LOCALBASE
-    ffPlatformPathAddAbsolute(&platform->dataDirs, _PATH_LOCALBASE "/share/");
+#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__)
+    ffPlatformPathAddAbsolute(&platform->dataDirs, FF_PATH_PKG_BASE "/share/");
 #endif
     ffPlatformPathAddAbsolute(&platform->dataDirs, FASTFETCH_TARGET_DIR_USR "/local/share/");
     ffPlatformPathAddAbsolute(&platform->dataDirs, FASTFETCH_TARGET_DIR_USR "/share/");
 }
 
-static void getUserName(FFPlatform* platform, const struct passwd* pwd)
-{
-    if (pwd)
-    {
+static void getUserName(FFPlatform* platform, const struct passwd* pwd) {
+    if (pwd) {
         ffStrbufSetS(&platform->userName, pwd->pw_name);
         ffStrbufSetS(&platform->fullUserName, pwd->pw_gecos);
         ffStrbufTrimSpace(&platform->fullUserName);
-    }
-    else
-    {
+    } else {
         ffStrbufSetS(&platform->userName, getenv("USER"));
     }
 }
 
-static void getHostName(FFPlatform* platform, const struct utsname* uts)
-{
+static void getHostName(FFPlatform* platform, const struct utsname* uts) {
     ffStrbufAppendS(&platform->hostName, uts->nodename);
 }
 
-static void getUserShell(FFPlatform* platform, const struct passwd* pwd)
-{
+static void getUserShell(FFPlatform* platform, const struct passwd* pwd) {
     const char* shell = getenv("SHELL");
-    if(!ffStrSet(shell) && pwd)
+    if (!ffStrSet(shell) && pwd) {
         shell = pwd->pw_shell;
+    }
 
     ffStrbufAppendS(&platform->userShell, shell);
 }
 
-static void getSysinfo(FFPlatformSysinfo* info, const struct utsname* uts)
-{
+static void getSysinfo(FFPlatformSysinfo* info, const struct utsname* uts) {
     ffStrbufAppendS(&info->name, uts->sysname);
     ffStrbufAppendS(&info->release, uts->release);
     ffStrbufAppendS(&info->version, uts->version);
-    #ifdef __HAIKU__
+#ifdef __HAIKU__
     /* historical reason */
-    if (ffStrEquals(uts->machine, "BePC"))
+    if (ffStrEquals(uts->machine, "BePC")) {
         ffStrbufSetStatic(&info->architecture, "i386");
-    else
-    #endif
-    ffStrbufAppendS(&info->architecture, uts->machine);
+    } else
+#endif
+        ffStrbufAppendS(&info->architecture, uts->machine);
 
-    #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__OpenBSD__) || defined(__NetBSD__)
+#if defined(__FreeBSD__) || defined(__APPLE__) || defined(__OpenBSD__) || defined(__NetBSD__)
     size_t length = sizeof(info->pageSize);
-    sysctl((int[]){ CTL_HW, HW_PAGESIZE }, 2, &info->pageSize, &length, NULL, 0);
-    #else
+    sysctl((int[]) { CTL_HW, HW_PAGESIZE }, 2, &info->pageSize, &length, nullptr, 0);
+#else
     info->pageSize = (uint32_t) sysconf(_SC_PAGESIZE);
-    #endif
+#endif
 }
 
-static void getCwd(FFPlatform* platform)
-{
+static void getCwd(FFPlatform* platform) {
     char cwd[PATH_MAX];
-    if (getcwd(cwd, sizeof(cwd)) != NULL)
-    {
+    if (getcwd(cwd, sizeof(cwd)) != nullptr) {
         ffStrbufSetS(&platform->cwd, cwd);
         ffStrbufEnsureEndsWithC(&platform->cwd, '/');
     }
 }
 
-void ffPlatformInitImpl(FFPlatform* platform)
-{
+void ffPlatformInitImpl(FFPlatform* platform) {
     platform->pid = (uint32_t) getpid();
     platform->uid = getuid();
     struct passwd* pwd = getpwuid(platform->uid);
 
     struct utsname uts;
-    if(uname(&uts) < 0)
+    if (uname(&uts) < 0) {
         memset(&uts, 0, sizeof(uts));
+    }
 
     getExePath(platform);
     getCwd(platform);

src/common/impl/FFPlatform_windows.c

@@ -1,12 +1,12 @@
 #include "FFPlatform_private.h"
 #include "common/io.h"
 #include "common/library.h"
-#include "common/mallocHelper.h"
-#include "common/stringUtils.h"
+#include "common/strutil.h"
 #include "common/windows/unicode.h"
 #include "common/windows/registry.h"
 #include "common/windows/nt.h"
 
+#include <stdalign.h>
 #include <windows.h>
 #include <shlobj.h>
 #include <sddl.h>
@@ -14,37 +14,42 @@
 #define SECURITY_WIN32 1 // For secext.h
 #include <secext.h>
 
-static void getExePath(FFPlatform* platform)
-{
+static void getExePath(FFPlatform* platform) {
     wchar_t exePathW[MAX_PATH];
-    DWORD exePathWLen = GetModuleFileNameW(NULL, exePathW, MAX_PATH);
-    if (exePathWLen == 0 || exePathWLen >= MAX_PATH) return;
 
-    FF_AUTO_CLOSE_FD HANDLE hPath = CreateFileW(exePathW, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
-    if (hPath != INVALID_HANDLE_VALUE)
-    {
-        DWORD len = GetFinalPathNameByHandleW(hPath, exePathW, MAX_PATH, FILE_NAME_OPENED);
-        if (len > 0 && len < MAX_PATH)
-            exePathWLen = len;
+    FF_AUTO_CLOSE_FD HANDLE hPath = CreateFileW(
+        ffGetPeb()->ProcessParameters->ImagePathName.Buffer,
+        GENERIC_READ,
+        FILE_SHARE_READ,
+        nullptr,
+        OPEN_EXISTING,
+        FILE_FLAG_BACKUP_SEMANTICS,
+        nullptr);
+    if (hPath != INVALID_HANDLE_VALUE) {
+        DWORD len = GetFinalPathNameByHandleW(hPath, exePathW, MAX_PATH, FILE_NAME_NORMALIZED);
+        if (len > 0 && len < MAX_PATH) {
+            ffStrbufSetNWS(&platform->exePath, len, exePathW);
+            if (ffStrbufStartsWithS(&platform->exePath, "\\\\?\\")) {
+                ffStrbufSubstrAfter(&platform->exePath, 3);
+            }
+        }
+    }
+
+    if (platform->exePath.length == 0) {
+        PCUNICODE_STRING imagePathName = &ffGetPeb()->ProcessParameters->ImagePathName;
+        ffStrbufSetNWS(&platform->exePath, imagePathName->Length / sizeof(wchar_t), imagePathName->Buffer);
     }
 
-    ffStrbufSetNWS(&platform->exePath, exePathWLen, exePathW);
-    if (ffStrbufStartsWithS(&platform->exePath, "\\\\?\\"))
-        ffStrbufSubstrAfter(&platform->exePath, 3);
     ffStrbufReplaceAllC(&platform->exePath, '\\', '/');
 }
 
-static void getHomeDir(FFPlatform* platform)
-{
-    PWSTR pPath = NULL;
-    if(SUCCEEDED(SHGetKnownFolderPath(&FOLDERID_Profile, KF_FLAG_DEFAULT, NULL, &pPath)))
-    {
+static void getHomeDir(FFPlatform* platform) {
+    PWSTR pPath = nullptr;
+    if (SUCCEEDED(SHGetKnownFolderPath(&FOLDERID_Profile, KF_FLAG_DEFAULT, nullptr, &pPath))) {
         ffStrbufSetWS(&platform->homeDir, pPath);
         ffStrbufReplaceAllC(&platform->homeDir, '\\', '/');
         ffStrbufEnsureEndsWithC(&platform->homeDir, '/');
-    }
-    else
-    {
+    } else {
         ffStrbufSetS(&platform->homeDir, getenv("USERPROFILE"));
         ffStrbufReplaceAllC(&platform->homeDir, '\\', '/');
         ffStrbufEnsureEndsWithC(&platform->homeDir, '/');
@@ -52,64 +57,57 @@ static void getHomeDir(FFPlatform* platform)
     CoTaskMemFree(pPath);
 }
 
-static void getCacheDir(FFPlatform* platform)
-{
-    PWSTR pPath = NULL;
-    if(SUCCEEDED(SHGetKnownFolderPath(&FOLDERID_LocalAppData, KF_FLAG_DEFAULT, NULL, &pPath)))
-    {
+static void getCacheDir(FFPlatform* platform) {
+    PWSTR pPath = nullptr;
+    if (SUCCEEDED(SHGetKnownFolderPath(&FOLDERID_LocalAppData, KF_FLAG_DEFAULT, nullptr, &pPath))) {
         ffStrbufSetWS(&platform->cacheDir, pPath);
         ffStrbufReplaceAllC(&platform->cacheDir, '\\', '/');
         ffStrbufEnsureEndsWithC(&platform->cacheDir, '/');
-    }
-    else
-    {
+    } else {
         ffStrbufAppend(&platform->cacheDir, &platform->homeDir);
         ffStrbufAppendS(&platform->cacheDir, "AppData/Local/");
     }
     CoTaskMemFree(pPath);
 }
 
-static void platformPathAddKnownFolder(FFlist* dirs, REFKNOWNFOLDERID folderId)
-{
-    PWSTR pPath = NULL;
-    if (SUCCEEDED(SHGetKnownFolderPath(folderId, KF_FLAG_DEFAULT, NULL, &pPath)))
-    {
+static void platformPathAddKnownFolder(FFlist* dirs, REFKNOWNFOLDERID folderId) {
+    PWSTR pPath = nullptr;
+    if (SUCCEEDED(SHGetKnownFolderPath(folderId, KF_FLAG_DEFAULT, nullptr, &pPath))) {
         FF_STRBUF_AUTO_DESTROY buffer = ffStrbufCreateWS(pPath);
         CoTaskMemFree(pPath);
         ffStrbufReplaceAllC(&buffer, '\\', '/');
         ffStrbufEnsureEndsWithC(&buffer, '/');
-        if (!ffListContains(dirs, &buffer, (void*) ffStrbufEqual))
-            ffStrbufInitMove((FFstrbuf*) ffListAdd(dirs), &buffer);
+        if (!FF_LIST_CONTAINS(*dirs, &buffer, ffStrbufEqual)) {
+            ffStrbufInitMove(FF_LIST_ADD(FFstrbuf, *dirs), &buffer);
+        }
     }
 }
 
-static void platformPathAddEnvSuffix(FFlist* dirs, const char* env, const char* suffix)
-{
+static void platformPathAddEnvSuffix(FFlist* dirs, const char* env, const char* suffix) {
     const char* value = getenv(env);
-    if(!ffStrSet(value))
+    if (!ffStrSet(value)) {
         return;
+    }
 
     FF_STRBUF_AUTO_DESTROY buffer = ffStrbufCreateA(64);
     ffStrbufAppendS(&buffer, value);
     ffStrbufReplaceAllC(&buffer, '\\', '/');
     ffStrbufEnsureEndsWithC(&buffer, '/');
-    if (suffix)
-    {
+    if (suffix) {
         ffStrbufAppendS(&buffer, suffix);
         ffStrbufEnsureEndsWithC(&buffer, '/');
     }
 
-    if (ffPathExists(buffer.chars, FF_PATHTYPE_DIRECTORY) && !ffListContains(dirs, &buffer, (void*) ffStrbufEqual))
-        ffStrbufInitMove((FFstrbuf*) ffListAdd(dirs), &buffer);
+    if (ffPathExists(buffer.chars, FF_PATHTYPE_DIRECTORY) && !FF_LIST_CONTAINS(*dirs, &buffer, ffStrbufEqual)) {
+        ffStrbufInitMove(FF_LIST_ADD(FFstrbuf, *dirs), &buffer);
+    }
 }
 
-static void getConfigDirs(FFPlatform* platform)
-{
-    if(getenv("MSYSTEM"))
-    {
+static void getConfigDirs(FFPlatform* platform) {
+    if (getenv("MSYSTEM")) {
         // We are in MSYS2 / Git Bash
         platformPathAddEnvSuffix(&platform->configDirs, "HOME", ".config/");
-        platformPathAddEnvSuffix(&platform->configDirs, "HOME", NULL);
+        platformPathAddEnvSuffix(&platform->configDirs, "HOME", nullptr);
         platformPathAddEnvSuffix(&platform->configDirs, "MINGW_PREFIX", "etc");
     }
 
@@ -120,13 +118,11 @@ static void getConfigDirs(FFPlatform* platform)
     ffPlatformPathAddHome(&platform->configDirs, platform, "");
 }
 
-static void getDataDirs(FFPlatform* platform)
-{
-    if(getenv("MSYSTEM") && getenv("HOME"))
-    {
+static void getDataDirs(FFPlatform* platform) {
+    if (getenv("MSYSTEM") && getenv("HOME")) {
         // We are in MSYS2 / Git Bash
         platformPathAddEnvSuffix(&platform->dataDirs, "HOME", ".local/share/");
-        platformPathAddEnvSuffix(&platform->dataDirs, "HOME", NULL);
+        platformPathAddEnvSuffix(&platform->dataDirs, "HOME", nullptr);
         platformPathAddEnvSuffix(&platform->dataDirs, "MINGW_PREFIX", "share");
     }
     ffPlatformPathAddHome(&platform->dataDirs, platform, ".local/share/");
@@ -136,122 +132,111 @@ static void getDataDirs(FFPlatform* platform)
     ffPlatformPathAddHome(&platform->dataDirs, platform, "");
 }
 
-static void getUserName(FFPlatform* platform)
-{
+static void getUserName(FFPlatform* platform) {
     wchar_t buffer[256];
     DWORD size = ARRAY_SIZE(buffer);
-    if (GetUserNameExW(NameDisplay, buffer, &size))
+    if (GetUserNameExW(NameDisplay, buffer, &size)) {
         ffStrbufSetWS(&platform->fullUserName, buffer);
+    }
 
-    size = ARRAY_SIZE(buffer);
-    if (GetUserNameW(buffer, &size)) // GetUserNameExW(10002)?
-    {
-        ffStrbufSetWS(&platform->userName, buffer);
+    NTSYSAPI NTSTATUS NTAPI LsaGetUserName(
+        _Outptr_ PLSA_UNICODE_STRING * UserName,
+        _Outptr_opt_ PLSA_UNICODE_STRING * DomainName);
+    PLSA_UNICODE_STRING userName = nullptr;
+    if (NT_SUCCESS(LsaGetUserName(&userName, nullptr))) {
+        ffStrbufSetNWS(&platform->userName, userName->Length / sizeof(wchar_t), userName->Buffer);
+        RtlFreeUnicodeString(userName); // Required. userName.Buffer is allocated separately
+        LsaFreeMemory(userName);
+    } else {
+        ffStrbufSetS(&platform->userName, getenv("USERNAME"));
+    }
 
-        size = 0;
-        DWORD refDomainSize = 0;
-        SID_NAME_USE sidNameUse = SidTypeUnknown;
-        LookupAccountNameW(NULL, buffer, NULL, &size, NULL, &refDomainSize, &sidNameUse);
-        if (size > 0)
-        {
-            FF_AUTO_FREE PSID sid = (PSID) malloc(size);
-            FF_AUTO_FREE LPWSTR refDomain = (LPWSTR) malloc(refDomainSize * sizeof(wchar_t));
-            if (LookupAccountNameW(NULL, buffer, sid, &size, refDomain, &refDomainSize, &sidNameUse))
-            {
-                LPWSTR sidString;
-                if (ConvertSidToStringSidW(sid, &sidString))
-                {
-                    ffStrbufSetWS(&platform->sid, sidString);
-                    LocalFree(sidString);
-                }
-            }
+    alignas(TOKEN_USER) char buf[SECURITY_MAX_SID_SIZE + sizeof(TOKEN_USER)];
+    if (NT_SUCCESS(NtQueryInformationToken(NtCurrentProcessToken(), TokenUser, buf, sizeof(buf), &size))) {
+        TOKEN_USER* tokenUser = (TOKEN_USER*) buf;
+        UNICODE_STRING sidString = { .Buffer = buffer, .Length = 0, .MaximumLength = sizeof(buffer) };
+        if (NT_SUCCESS(RtlConvertSidToUnicodeString(&sidString, tokenUser->User.Sid, FALSE))) {
+            ffStrbufSetNWS(&platform->sid, sidString.Length / sizeof(wchar_t), sidString.Buffer);
         }
     }
-    else
-        ffStrbufSetS(&platform->userName, getenv("USERNAME"));
 }
 
-static void getHostName(FFPlatform* platform)
-{
+static void getHostName(FFPlatform* platform) {
     wchar_t buffer[256];
     DWORD len = ARRAY_SIZE(buffer);
-    if (GetComputerNameExW(ComputerNameDnsHostname, buffer, &len) && len > 0)
+    if (GetComputerNameExW(ComputerNameDnsHostname, buffer, &len) && len > 0) {
         ffStrbufSetNWS(&platform->hostName, len, buffer);
-    else
-    {
+    } else {
         len = ARRAY_SIZE(buffer);
-        if (GetComputerNameExW(ComputerNameNetBIOS, buffer, &len) && len > 0)
+        if (GetComputerNameExW(ComputerNameNetBIOS, buffer, &len) && len > 0) {
             ffStrbufSetNWS(&platform->hostName, len, buffer);
+        }
     }
 }
 
-static void getUserShell(FFPlatform* platform)
-{
+static void getUserShell(FFPlatform* platform) {
     // Works in MSYS2
     const char* userShell = getenv("SHELL");
-    if (userShell)
-    {
+    if (userShell) {
         ffStrbufAppendS(&platform->userShell, userShell);
         ffStrbufReplaceAllC(&platform->userShell, '\\', '/');
     }
 }
 
-static const char* detectWine(void)
-{
-    const char * __cdecl wine_get_version(void);
-    HMODULE hntdll = GetModuleHandleW(L"ntdll.dll");
-    if (!hntdll) return NULL;
+static const char* detectWine(void) {
+    const char* __cdecl wine_get_version(void);
+    void* hntdll = ffLibraryGetModule(L"ntdll.dll");
+    if (!hntdll) {
+        return nullptr;
+    }
     FF_LIBRARY_LOAD_SYMBOL_LAZY(hntdll, wine_get_version);
-    if (!ffwine_get_version) return NULL;
+    if (!ffwine_get_version) {
+        return nullptr;
+    }
     return ffwine_get_version();
 }
 
-static void getSystemReleaseAndVersion(FFPlatformSysinfo* info)
-{
-    FF_HKEY_AUTO_DESTROY hKey = NULL;
-    if(!ffRegOpenKeyForRead(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", &hKey, NULL))
+static void getSystemReleaseAndVersion(FFPlatformSysinfo* info) {
+    FF_AUTO_CLOSE_FD HANDLE hKey = nullptr;
+    if (!ffRegOpenKeyForRead(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", &hKey, nullptr)) {
         return;
+    }
 
     uint32_t ubr = 0;
-    ffRegReadUint(hKey, L"UBR", &ubr, NULL);
+    ffRegReadValues(hKey, 2, (FFRegValueArg[]) {
+                                 FF_ARG(ubr, L"UBR"),
+                                 FF_ARG(info->version, L"BuildLabEx"),
+                             },
+        nullptr);
 
-    ffStrbufAppendF(&info->release,
+    PPEB_FULL peb = ffGetPeb();
+
+    ffStrbufSetF(&info->release,
         "%u.%u.%u.%u",
-        (unsigned) SharedUserData->NtMajorVersion,
-        (unsigned) SharedUserData->NtMinorVersion,
-        (unsigned) SharedUserData->NtBuildNumber,
+        (unsigned) peb->OSMajorVersion,
+        (unsigned) peb->OSMinorVersion,
+        (unsigned) peb->OSBuildNumber,
         (unsigned) ubr);
 
-    ffRegReadStrbuf(hKey, L"BuildLabEx", &info->version, NULL);
-
     const char* wineVersion = detectWine();
-    if (wineVersion)
-    {
-        if (instance.config.general.detectVersion)
-            ffStrbufSetF(&info->name, "Wine_%s", wineVersion);
-        else
-            ffStrbufSetStatic(&info->name, "Wine");
-    }
-    else
+    if (wineVersion) {
+        ffStrbufSetF(&info->name, "Wine_%s", wineVersion);
+    } else {
         ffStrbufSetStatic(&info->name, "WIN32_NT");
+    }
 }
 
-static void getSystemPageSize(FFPlatformSysinfo* info)
-{
+static void getSystemPageSize(FFPlatformSysinfo* info) {
     SYSTEM_BASIC_INFORMATION sbi;
-    if (NT_SUCCESS(NtQuerySystemInformation(SystemBasicInformation, &sbi, sizeof(sbi), NULL)))
+    if (NT_SUCCESS(NtQuerySystemInformation(SystemBasicInformation, &sbi, sizeof(sbi), nullptr))) {
         info->pageSize = sbi.PhysicalPageSize;
-    else
+    } else {
         info->pageSize = 4096;
+    }
 }
 
-static void getSystemArchitecture(FFPlatformSysinfo* info)
-{
-    SYSTEM_PROCESSOR_INFORMATION spi;
-    if (NT_SUCCESS(NtQuerySystemInformation(SystemProcessorInformation, &spi, sizeof(spi), NULL)))
-    {
-        switch (spi.ProcessorArchitecture)
-        {
+static void getSystemArchitecture(FFPlatformSysinfo* info) {
+    switch (SharedUserData->NativeProcessorArchitecture) {
         case PROCESSOR_ARCHITECTURE_AMD64:
             ffStrbufSetStatic(&info->architecture, "x86_64");
             break;
@@ -259,21 +244,7 @@ static void getSystemArchitecture(FFPlatformSysinfo* info)
             ffStrbufSetStatic(&info->architecture, "ia64");
             break;
         case PROCESSOR_ARCHITECTURE_INTEL:
-            switch (spi.ProcessorLevel)
-            {
-                case 4:
-                    ffStrbufSetStatic(&info->architecture, "i486");
-                    break;
-                case 5:
-                    ffStrbufSetStatic(&info->architecture, "i586");
-                    break;
-                case 6:
-                    ffStrbufSetStatic(&info->architecture, "i686");
-                    break;
-                default:
-                    ffStrbufSetStatic(&info->architecture, "i386");
-                    break;
-            }
+            ffStrbufSetStatic(&info->architecture, "i686");
             break;
         case PROCESSOR_ARCHITECTURE_ARM64:
             ffStrbufSetStatic(&info->architecture, "aarch64");
@@ -297,26 +268,18 @@ static void getSystemArchitecture(FFPlatformSysinfo* info)
         default:
             ffStrbufSetStatic(&info->architecture, "unknown");
             break;
-        }
     }
 }
 
-static void getCwd(FFPlatform* platform)
-{
-    #if _WIN64
-    static_assert(
-        offsetof(RTL_USER_PROCESS_PARAMETERS, Reserved2[5]) == 0x38,
-        "CurrentDirectory should be at offset 0x38 in RTL_USER_PROCESS_PARAMETERS. Structure layout mismatch detected.");
-    #endif
-    PCURDIR cwd = (PCURDIR) &NtCurrentTeb()->ProcessEnvironmentBlock->ProcessParameters->Reserved2[5];
+static void getCwd(FFPlatform* platform) {
+    PCURDIR cwd = &ffGetPeb()->ProcessParameters->CurrentDirectory;
     ffStrbufSetNWS(&platform->cwd, cwd->DosPath.Length / sizeof(WCHAR), cwd->DosPath.Buffer);
     ffStrbufReplaceAllC(&platform->cwd, '\\', '/');
     ffStrbufEnsureEndsWithC(&platform->cwd, '/');
 }
 
-void ffPlatformInitImpl(FFPlatform* platform)
-{
-    platform->pid = (uint32_t) GetCurrentProcessId();
+void ffPlatformInitImpl(FFPlatform* platform) {
+    platform->pid = (uint32_t) (uintptr_t) ffGetTeb()->ClientId.UniqueProcess;
     getExePath(platform);
     getCwd(platform);
     getHomeDir(platform);

src/common/impl/FFlist.c

@@ -3,36 +3,23 @@
 #include <stdlib.h>
 #include <string.h>
 
-void* ffListAdd(FFlist* list)
-{
-    if(list->length == list->capacity)
-    {
-        list->capacity = list->capacity == 0 ? FF_LIST_DEFAULT_ALLOC : list->capacity * 2;
-        // realloc(NULL, newSize) is same as malloc(newSize)
-        list->data = realloc(list->data, (size_t)list->capacity * list->elementSize);
+bool ffListShift(FFlist* list, uint32_t elementSize, void* __restrict result) {
+    if (list->length == 0) {
+        return false;
     }
 
-    ++list->length;
-    return ffListGet(list, list->length - 1);
-}
-
-bool ffListShift(FFlist* list, void* result)
-{
-    if(list->length == 0)
-        return false;
-
-    memcpy(result, list->data, list->elementSize);
-    memmove(list->data, list->data + list->elementSize, (size_t) list->elementSize * (list->length - 1));
+    memcpy(result, list->data, elementSize);
+    memmove(list->data, list->data + elementSize, (size_t) elementSize * (list->length - 1));
     --list->length;
     return true;
 }
 
-bool ffListPop(FFlist* list, void* result)
-{
-    if(list->length == 0)
+bool ffListPop(FFlist* list, uint32_t elementSize, void* __restrict result) {
+    if (list->length == 0) {
         return false;
+    }
 
-    memcpy(result, ffListGet(list, list->length - 1), list->elementSize);
+    memcpy(result, ffListGet(list, elementSize, list->length - 1), elementSize);
     --list->length;
     return true;
 }

src/common/impl/base64.c

@@ -1,14 +1,15 @@
 #include "common/base64.h"
+#include "common/endian.h"
 
 // https://github.com/kostya/benchmarks/blob/master/base64/test-nolib.c#L145
-void ffBase64EncodeRaw(uint32_t size, const char *str, uint32_t *out_size, char *output)
-{
+void ffBase64EncodeRaw(uint32_t size, const char* str, uint32_t* out_size, char* output) {
     static const char chars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-    char *out = output;
-    const char *ends = str + (size - size % 3);
-    while (str != ends)
-    {
-        uint32_t n = __builtin_bswap32(*(uint32_t *)str);
+    char* out = output;
+    const char* ends = str + (size - size % 3);
+    while (str != ends) {
+        uint32_t n = *(uint32_t*) str;
+        // The 3 input bytes must be laid out big-endian (str[0] in the most significant position).
+        n = FF_READ_BE(n);
         *out++ = chars[(n >> 26) & 63];
         *out++ = chars[(n >> 20) & 63];
         *out++ = chars[(n >> 14) & 63];
@@ -16,94 +17,94 @@ void ffBase64EncodeRaw(uint32_t size, const char *str, uint32_t *out_size, char
         str += 3;
     }
 
-    if (size % 3 == 1)
-    {
-        uint64_t n = (uint64_t)*str << 16;
+    if (size % 3 == 1) {
+        uint64_t n = (uint64_t) *str << 16;
         *out++ = chars[(n >> 18) & 63];
         *out++ = chars[(n >> 12) & 63];
         *out++ = '=';
         *out++ = '=';
-    }
-    else if (size % 3 == 2)
-    {
-        uint64_t n = (uint64_t)*str++ << 16;
-        n |= (uint64_t)*str << 8;
+    } else if (size % 3 == 2) {
+        uint64_t n = (uint64_t) *str++ << 16;
+        n |= (uint64_t) *str << 8;
         *out++ = chars[(n >> 18) & 63];
         *out++ = chars[(n >> 12) & 63];
         *out++ = chars[(n >> 6) & 63];
         *out++ = '=';
     }
     *out = '\0';
-    *out_size = (uint32_t)(out - output);
+    *out_size = (uint32_t) (out - output);
 }
 
 static uint8_t decode_table[256];
 
-void init_decode_table()
-{
+static void init_decode_table() {
     uint8_t ch = 0;
-    do
-    {
+    do {
         int32_t code = -1;
-        if (ch >= 'A' && ch <= 'Z')
+        if (ch >= 'A' && ch <= 'Z') {
             code = ch - 0x41;
-        if (ch >= 'a' && ch <= 'z')
+        }
+        if (ch >= 'a' && ch <= 'z') {
             code = ch - 0x47;
-        if (ch >= '0' && ch <= '9')
+        }
+        if (ch >= '0' && ch <= '9') {
             code = ch + 0x04;
-        if (ch == '+' || ch == '-')
+        }
+        if (ch == '+' || ch == '-') {
             code = 0x3E;
-        if (ch == '/' || ch == '_')
+        }
+        if (ch == '/' || ch == '_') {
             code = 0x3F;
+        }
         decode_table[ch] = (uint8_t) code;
     } while (ch++ < 0xFF);
 }
 
 #define next_char(x) uint8_t x = decode_table[(uint8_t) *str++];
 
-bool ffBase64DecodeRaw(uint32_t size, const char *str, uint32_t *out_size, char *output)
-{
-    if (*(uint64_t*) decode_table == 0)
+bool ffBase64DecodeRaw(uint32_t size, const char* str, uint32_t* out_size, char* output) {
+    if (*(uint64_t*) decode_table == 0) {
         init_decode_table();
+    }
 
-    char *out = output;
-    while (size > 0 && (str[size - 1] == '\n' || str[size - 1] == '\r' || str[size - 1] == '='))
+    char* out = output;
+    while (size > 0 && (str[size - 1] == '\n' || str[size - 1] == '\r' || str[size - 1] == '=')) {
         size--;
+    }
 
-    const char *ends = str + size - 4;
-    while (true)
-    {
-        if (str > ends)
+    const char* ends = str + size - 4;
+    while (true) {
+        if (str > ends) {
             break;
-        while (*str == '\n' || *str == '\r')
+        }
+        while (*str == '\n' || *str == '\r') {
             str++;
+        }
 
-        if (str > ends)
+        if (str > ends) {
             break;
+        }
         next_char(a);
         next_char(b);
         next_char(c);
         next_char(d);
 
-        *out++ = (char)(a << 2 | b >> 4);
-        *out++ = (char)(b << 4 | c >> 2);
-        *out++ = (char)(c << 6 | d >> 0);
+        *out++ = (char) (a << 2 | b >> 4);
+        *out++ = (char) (b << 4 | c >> 2);
+        *out++ = (char) (c << 6 | d >> 0);
     }
 
     uint8_t mod = (uint8_t) (ends - str + 4) % 4;
-    if (mod == 2)
-    {
+    if (mod == 2) {
         next_char(a);
         next_char(b);
-        *out++ = (char)(a << 2 | b >> 4);
-    }
-    else if (mod == 3)
-    {
+        *out++ = (char) (a << 2 | b >> 4);
+    } else if (mod == 3) {
         next_char(a);
         next_char(b);
         next_char(c);
-        *out++ = (char)(a << 2 | b >> 4);
-        *out++ = (char)(b << 4 | c >> 2);
+        *out++ = (char) (a << 2 | b >> 4);
+        *out++ = (char) (b << 4 | c >> 2);
     }
 
     *out = '\0';

src/common/impl/binary_apple.c

@@ -1,11 +1,10 @@
 #include "common/binary.h"
 #include "common/io.h"
-#include "common/stringUtils.h"
-#include "common/mallocHelper.h"
+#include "common/strutil.h"
 
-#include <stdlib.h>
 #include <string.h>
 #include <fcntl.h>
+#include <sys/mman.h>
 #include <mach-o/loader.h>
 #include <mach-o/swap.h>
 #include <mach-o/fat.h>
@@ -14,19 +13,39 @@
 
 // Ref: https://github.com/AlexDenisov/segment_dumper/blob/master/main.c
 
+typedef struct {
+    const uint8_t* data;
+    size_t length;
+} FFMemoryMapping;
+
+static inline void wrapMunmap(FFMemoryMapping* mapping) {
+    assert(mapping);
+    if (mapping->data == nullptr || mapping->data == MAP_FAILED) {
+        return;
+    }
+    munmap((void*) mapping->data, mapping->length);
+}
+
 /**
- * Helper function to read data from a file at a specific offset
+ * Helper function to access data from a memory-mapped file at a specific offset
  */
-static inline bool readData(FILE *objFile, void *buf, size_t size, off_t offset)
-{
-    fseek(objFile, offset, SEEK_SET);
-    return fread(buf, 1, size, objFile) == size;
+static inline const void* readData(const FFMemoryMapping* mapping, size_t size, off_t offset) {
+    if (offset < 0) {
+        return nullptr;
+    }
+
+    size_t start = (size_t) offset;
+    if (start > mapping->length || size > mapping->length - start) {
+        return nullptr;
+    }
+
+    return mapping->data + start;
 }
 
 /**
  * Handles a Mach-O section by extracting strings from the __cstring section
  *
- * @param objFile File handle to the Mach-O object file
+ * @param mapping Memory mapping of the Mach-O object file
  * @param name Section name to check
  * @param offset Offset of the section in the file
  * @param size Size of the section
@@ -36,23 +55,30 @@ static inline bool readData(FILE *objFile, void *buf, size_t size, off_t offset)
  *
  * @return true to continue processing, false to stop
  */
-static bool handleMachSection(FILE *objFile, const char *name, off_t offset, size_t size, bool (*cb)(const char *str, uint32_t len, void *userdata), void *userdata, uint32_t minLength)
-{
-    if (!ffStrEquals(name, "__cstring")) return true;
-
-    FF_AUTO_FREE char* data = (char*) malloc(size);
-    if (!readData(objFile, data, size, offset))
+static bool handleMachSection(const FFMemoryMapping* mapping, const char* name, off_t offset, size_t size, bool (*cb)(const char* str, uint32_t len, void* userdata), void* userdata, uint32_t minLength) {
+    if (!ffStrEquals(name, "__cstring")) {
         return true;
+    }
 
-    for (size_t off = 0; off < size; ++off)
-    {
-        const char* p = (const char*) data + off;
-        if (*p == '\0') continue;
-        uint32_t len = (uint32_t) strlen(p);
-        if (len < minLength) continue;
-        if (*p >= ' ' && *p <= '~') // Ignore control characters
-        {
-            if (!cb(p, len, userdata)) return false;
+    const char* data = readData(mapping, size, offset);
+    if (!data) {
+        return true;
+    }
+
+    for (size_t off = 0; off < size; ++off) {
+        const char* p = data + off;
+        if (*p == '\0') {
+            continue;
+        }
+        uint32_t len = (uint32_t) strnlen(p, size - off);
+        if (len < minLength) {
+            off += len; // Skip short strings
+            continue;
+        }
+        if (*p >= ' ' && *p <= '~') { // Ignore control characters
+            if (!cb(p, len, userdata)) {
+                return false;
+            }
         }
         off += len;
     }
@@ -66,87 +92,95 @@ static bool handleMachSection(FILE *objFile, const char *name, off_t offset, siz
  * LC_SEGMENT or LC_SEGMENT_64 commands that contain the __TEXT segment.
  * It then processes the sections within that segment to extract strings.
  *
- * @param objFile File handle to the Mach-O object file
+ * @param mapping Memory mapping of the Mach-O object file
  * @param offset Offset of the Mach header in the file
  * @param is_64 Whether this is a 64-bit Mach-O header
  * @param cb Callback function to process strings
  * @param userdata User data for the callback
  * @param minLength Minimum string length to extract
  *
- * @return NULL on success, error message on failure
+ * @return nullptr on success, error message on failure
  */
-static const char* dumpMachHeader(FILE *objFile, off_t offset, bool is_64, bool (*cb)(const char *str, uint32_t len, void *userdata), void *userdata, uint32_t minLength)
-{
+static const char* dumpMachHeader(const FFMemoryMapping* mapping, off_t offset, bool is_64, bool (*cb)(const char* str, uint32_t len, void* userdata), void* userdata, uint32_t minLength) {
     uint32_t ncmds;
     off_t loadCommandsOffset = offset;
 
-    if (is_64)
-    {
-        struct mach_header_64 header;
-        if (!readData(objFile, &header, sizeof(header), offset))
+    if (is_64) {
+        const struct mach_header_64* header = readData(mapping, sizeof(struct mach_header_64), offset);
+        if (!header) {
             return "read mach header failed";
+        }
 
-        ncmds = header.ncmds;
-        loadCommandsOffset += sizeof(header);
-    }
-    else
-    {
-        struct mach_header header;
-        if (!readData(objFile, &header, sizeof(header), offset))
+        ncmds = header->ncmds;
+        loadCommandsOffset += sizeof(*header);
+    } else {
+        const struct mach_header* header = readData(mapping, sizeof(struct mach_header), offset);
+        if (!header) {
             return "read mach header failed";
+        }
 
-        ncmds = header.ncmds;
-        loadCommandsOffset += sizeof(header);
+        ncmds = header->ncmds;
+        loadCommandsOffset += sizeof(*header);
     }
 
     off_t commandOffset = loadCommandsOffset;
-    struct load_command cmd = {};
-    for (uint32_t i = 0U; i < ncmds; i++, commandOffset += cmd.cmdsize)
-    {
-        if (!readData(objFile, &cmd, sizeof(cmd), commandOffset))
-            continue;
-
-        if (cmd.cmd == LC_SEGMENT_64)
-        {
-            struct segment_command_64 segment;
-            if (!readData(objFile, &segment, sizeof(segment), commandOffset))
-                continue;
-
-            if (!ffStrEquals(segment.segname, "__TEXT")) continue;
-
-            for (uint32_t j = 0U; j < segment.nsects; j++)
-            {
-                struct section_64 section;
-                if (!readData(objFile, &section, sizeof(section), (off_t) ((size_t) commandOffset + sizeof(segment) + j * sizeof(section))))
-                    continue;
-
-                if (!handleMachSection(objFile, section.sectname, section.offset, section.size, cb, userdata, minLength))
-                    return NULL;
-            }
-        }
-        else if (cmd.cmd == LC_SEGMENT)
-        {
-            struct segment_command segment;
-            if (!readData(objFile, &segment, sizeof(segment), commandOffset))
-                continue;
-
-            if (!ffStrEquals(segment.segname, "__TEXT")) continue;
-
-            for (uint32_t j = 0; j < segment.nsects; j++)
-            {
-                struct section section;
-                if (!readData(objFile, &section, sizeof(section), (off_t) ((size_t) commandOffset + sizeof(segment) + j * sizeof(section))))
-                    continue;
-
-                if (!handleMachSection(objFile, section.sectname, section.offset, section.size, cb, userdata, minLength))
-                    return NULL;
-            }
+    const struct load_command* cmd = nullptr;
+    for (uint32_t i = 0U; i < ncmds; i++, commandOffset += cmd->cmdsize) {
+        cmd = readData(mapping, sizeof(*cmd), commandOffset);
+        if (!cmd) {
+            break;
         }
 
-        return NULL;
+        if (cmd->cmdsize < sizeof(*cmd)) {
+            break;
+        }
+
+        if (cmd->cmd == LC_SEGMENT_64) {
+            const struct segment_command_64* segment = readData(mapping, sizeof(struct segment_command_64), commandOffset);
+            if (!segment) {
+                continue;
+            }
+
+            if (!ffStrEquals(segment->segname, "__TEXT")) {
+                continue;
+            }
+
+            for (uint32_t j = 0U; j < segment->nsects; j++) {
+                off_t sectionOffset = commandOffset + (off_t) sizeof(*segment) + (off_t) (j * sizeof(struct section_64));
+                const struct section_64* section = readData(mapping, sizeof(struct section_64), sectionOffset);
+                if (!section) {
+                    continue;
+                }
+
+                if (!handleMachSection(mapping, section->sectname, (off_t) section->offset, (size_t) section->size, cb, userdata, minLength)) {
+                    return nullptr;
+                }
+            }
+        } else if (cmd->cmd == LC_SEGMENT) {
+            const struct segment_command* segment = readData(mapping, sizeof(struct segment_command), commandOffset);
+            if (!segment) {
+                continue;
+            }
+
+            if (!ffStrEquals(segment->segname, "__TEXT")) {
+                continue;
+            }
+
+            for (uint32_t j = 0; j < segment->nsects; j++) {
+                off_t sectionOffset = commandOffset + (off_t) sizeof(*segment) + (off_t) (j * sizeof(struct section));
+                const struct section* section = readData(mapping, sizeof(struct section), sectionOffset);
+                if (!section) {
+                    continue;
+                }
+
+                if (!handleMachSection(mapping, section->sectname, (off_t) section->offset, (size_t) section->size, cb, userdata, minLength)) {
+                    return nullptr;
+                }
+            }
+        }
     }
 
-    return NULL;
+    return nullptr;
 }
 
 /**
@@ -156,56 +190,65 @@ static const char* dumpMachHeader(FILE *objFile, off_t offset, bool is_64, bool
  * multiple Mach-O binaries for different architectures. It extracts and processes
  * each embedded Mach-O file.
  *
- * @param objFile File handle to the universal binary
+ * @param mapping Memory mapping of the universal binary
  * @param cb Callback function to process strings
  * @param userdata User data for the callback
  * @param minLength Minimum string length to extract
  *
- * @return NULL on success, error message on failure
+ * @return nullptr on success, error message on failure
  */
-static const char* dumpFatHeader(FILE *objFile, bool (*cb)(const char *str, uint32_t len, void *userdata), void *userdata, uint32_t minLength)
-{
-    struct fat_header header;
-    if (!readData(objFile, &header, sizeof(header), 0))
+static const char* dumpFatHeader(const FFMemoryMapping* mapping, bool (*cb)(const char* str, uint32_t len, void* userdata), void* userdata, uint32_t minLength) {
+    const struct fat_header* headerRaw = readData(mapping, sizeof(struct fat_header), 0);
+    if (!headerRaw) {
         return "read fat header failed";
+    }
+
+    struct fat_header header = *headerRaw;
 
     bool needSwap = header.magic == FAT_CIGAM || header.magic == FAT_CIGAM_64;
 
-    if (needSwap) swap_fat_header(&header, NX_UnknownByteOrder);
+    if (needSwap) {
+        swap_fat_header(&header, NX_UnknownByteOrder);
+    }
 
-    for (uint32_t i = 0U; i < header.nfat_arch; i++)
-    {
+    for (uint32_t i = 0U; i < header.nfat_arch; i++) {
         off_t machHeaderOffset = 0;
-        if (header.magic == FAT_MAGIC)
-        {
-            struct fat_arch arch;
-            if (!readData(objFile, &arch, sizeof(arch), (off_t) (sizeof(header) + i * sizeof(arch))))
+        if (header.magic == FAT_MAGIC) {
+            off_t archOffset = (off_t) sizeof(struct fat_header) + (off_t) (i * sizeof(struct fat_arch));
+            const struct fat_arch* archRaw = readData(mapping, sizeof(struct fat_arch), archOffset);
+            if (!archRaw) {
                 continue;
+            }
 
-            if (needSwap)
+            struct fat_arch arch = *archRaw;
+
+            if (needSwap) {
                 swap_fat_arch(&arch, 1, NX_UnknownByteOrder);
-            machHeaderOffset = (off_t)arch.offset;
-        }
-        else
-        {
-            struct fat_arch_64 arch;
-            if (!readData(objFile, &arch, sizeof(arch), (off_t) (sizeof(header) + i * sizeof(arch))))
+            }
+            machHeaderOffset = (off_t) arch.offset;
+        } else {
+            off_t archOffset = (off_t) sizeof(struct fat_header) + (off_t) (i * sizeof(struct fat_arch_64));
+            const struct fat_arch_64* archRaw = readData(mapping, sizeof(struct fat_arch_64), archOffset);
+            if (!archRaw) {
                 continue;
+            }
 
-            if (needSwap)
+            struct fat_arch_64 arch = *archRaw;
+
+            if (needSwap) {
                 swap_fat_arch_64(&arch, 1, NX_UnknownByteOrder);
+            }
 
-            machHeaderOffset = (off_t)arch.offset;
+            machHeaderOffset = (off_t) arch.offset;
         }
 
-        uint32_t magic;
-        if (!readData(objFile, &magic, sizeof(magic), machHeaderOffset))
+        const uint32_t* magic = readData(mapping, sizeof(uint32_t), machHeaderOffset);
+        if (!magic) {
             continue;
+        }
 
-        if (magic == MH_MAGIC_64 || magic == MH_MAGIC)
-        {
-            dumpMachHeader(objFile, machHeaderOffset, magic == MH_MAGIC_64, cb, userdata, minLength);
-            return NULL;
+        if (*magic == MH_MAGIC_64 || *magic == MH_MAGIC) {
+            return dumpMachHeader(mapping, machHeaderOffset, *magic == MH_MAGIC_64, cb, userdata, minLength);
         }
     }
     return "Unsupported fat header";
@@ -219,26 +262,42 @@ static const char* dumpFatHeader(FILE *objFile, bool (*cb)(const char *str, uint
  * It locates the __cstring section in the __TEXT segment which contains
  * the string literals used in the program.
  */
-const char *ffBinaryExtractStrings(const char *machoFile, bool (*cb)(const char *str, uint32_t len, void *userdata), void *userdata, uint32_t minLength)
-{
-    FF_AUTO_CLOSE_FILE FILE *objFile = fopen(machoFile, "rb");
-    if (objFile == NULL)
+const char* ffBinaryExtractStrings(const char* machoFile, bool (*cb)(const char* str, uint32_t len, void* userdata), void* userdata, uint32_t minLength) {
+    FF_AUTO_CLOSE_FD int fd = open(machoFile, O_RDONLY | O_CLOEXEC);
+    if (fd < 0) {
         return "File could not be opened";
+    }
+
+    struct stat st;
+    if (fstat(fd, &st) != 0 || st.st_size <= 0) {
+        return "Failed to stat file";
+    }
+
+    [[gnu::cleanup(wrapMunmap)]] FFMemoryMapping mapping = {
+        .data = mmap(nullptr, (size_t) st.st_size, PROT_READ, MAP_PRIVATE, fd, 0),
+        .length = (size_t) st.st_size,
+    };
+    if (mapping.data == MAP_FAILED) {
+        return "mmap failed";
+    }
 
     // Read the magic number to determine the type of binary
-    uint32_t magic;
-    if (!readData(objFile, &magic, sizeof(magic), 0))
+    const uint32_t* magic = readData(&mapping, sizeof(uint32_t), 0);
+    if (!magic) {
         return "read magic number failed";
+    }
 
     // Check for supported formats
     // MH_CIGAM and MH_CIGAM_64 seem to be no longer used, as `swap_mach_header` is marked as deprecated.
     // However FAT_CIGAM and FAT_CIGAM_64 are still used (/usr/bin/vim).
-    if (magic != MH_MAGIC && magic != MH_MAGIC_64 && magic != FAT_CIGAM && magic != FAT_CIGAM_64 && magic != FAT_MAGIC && magic != FAT_MAGIC_64)
+    if (*magic != MH_MAGIC && *magic != MH_MAGIC_64 && *magic != FAT_CIGAM && *magic != FAT_CIGAM_64 && *magic != FAT_MAGIC && *magic != FAT_MAGIC_64) {
         return "Unsupported format or big endian mach-o file";
+    }
 
     // Process either a fat binary or a regular Mach-O binary
-    if (magic == FAT_MAGIC || magic == FAT_MAGIC_64 || magic == FAT_CIGAM || magic == FAT_CIGAM_64)
-        return dumpFatHeader(objFile, cb, userdata, minLength);
-    else
-        return dumpMachHeader(objFile, 0, magic == MH_MAGIC_64, cb, userdata, minLength);
+    if (*magic == FAT_MAGIC || *magic == FAT_MAGIC_64 || *magic == FAT_CIGAM || *magic == FAT_CIGAM_64) {
+        return dumpFatHeader(&mapping, cb, userdata, minLength);
+    } else {
+        return dumpMachHeader(&mapping, 0, *magic == MH_MAGIC_64, cb, userdata, minLength);
+    }
 }

src/common/impl/binary_linux.c

@@ -2,12 +2,12 @@
 
 #if defined(FF_HAVE_ELF) || defined(__sun) || (defined(__FreeBSD__) && !defined(__DragonFly__)) || defined(__OpenBSD__) || defined(__NetBSD__)
 
-#include "common/io.h"
-#include "common/library.h"
-#include "common/stringUtils.h"
+    #include "common/io.h"
+    #include "common/library.h"
+    #include "common/strutil.h"
 
-#include <libelf.h> // #1254
-#include <fcntl.h>
+    #include <libelf.h> // #1254
+    #include <fcntl.h>
 
 /**
  * Structure to hold dynamically loaded libelf function pointers
@@ -36,15 +36,15 @@ struct FFElfData {
  *
  * The function supports both 32-bit and 64-bit ELF formats.
  */
-const char* ffBinaryExtractStrings(const char* elfFile, bool (*cb)(const char* str, uint32_t len, void* userdata), void* userdata, uint32_t minLength)
-{
+const char* ffBinaryExtractStrings(const char* elfFile, bool (*cb)(const char* str, uint32_t len, void* userdata), void* userdata, uint32_t minLength) {
     // Initialize libelf if not already done
-    if (!elfData.inited)
-    {
+    if (!elfData.inited) {
         elfData.inited = true;
         FF_LIBRARY_LOAD_MESSAGE(libelf, "libelf" FF_LIBRARY_EXTENSION, 1);
         FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libelf, elfData, elf_version)
-        if (elfData.ffelf_version(EV_CURRENT) == EV_NONE) return "elf_version() failed";
+        if (elfData.ffelf_version(EV_CURRENT) == EV_NONE) {
+            return "elf_version() failed";
+        }
 
         // Load all required libelf functions
         FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libelf, elfData, elf_begin)
@@ -56,59 +56,73 @@ const char* ffBinaryExtractStrings(const char* elfFile, bool (*cb)(const char* s
         FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libelf, elfData, elf_strptr)
         FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libelf, elfData, elf_end)
 
-        libelf = NULL;
+        libelf = nullptr;
     }
 
-    if (elfData.ffelf_end == NULL)
+    if (elfData.ffelf_end == nullptr) {
         return "load libelf failed";
+    }
 
     // Open the ELF file
     FF_AUTO_CLOSE_FD int fd = open(elfFile, O_RDONLY | O_CLOEXEC);
-    if (fd < 0) return "open() failed";
+    if (fd < 0) {
+        return "open() failed";
+    }
 
-    Elf* elf = elfData.ffelf_begin(fd, ELF_C_READ, NULL);
-    if (elf == NULL) return "elf_begin() failed";
+    Elf* elf = elfData.ffelf_begin(fd, ELF_C_READ, nullptr);
+    if (elf == nullptr) {
+        return "elf_begin() failed";
+    }
 
     // Get the section header string table index
     size_t shstrndx = 0;
-    if (elfData.ffelf_getshdrstrndx(elf, &shstrndx) < 0)
-    {
+    if (elfData.ffelf_getshdrstrndx(elf, &shstrndx) < 0) {
         elfData.ffelf_end(elf);
         return "elf_getshdrstrndx() failed";
     }
 
     // Iterate through all sections, looking for .rodata which contains string literals
-    Elf_Scn* scn = NULL;
-    while ((scn = elfData.ffelf_nextscn(elf, scn)) != NULL)
-    {
+    Elf_Scn* scn = nullptr;
+    while ((scn = elfData.ffelf_nextscn(elf, scn)) != nullptr) {
         // Try 64-bit section header first, then 32-bit if that fails
         Elf64_Shdr* shdr64 = elfData.ffelf64_getshdr(scn);
-        Elf32_Shdr* shdr32 = NULL;
-        if (shdr64 == NULL)
-        {
+        Elf32_Shdr* shdr32 = nullptr;
+        if (shdr64 == nullptr) {
             shdr32 = elfData.ffelf32_getshdr(scn);
-            if (shdr32 == NULL) continue;
+            if (shdr32 == nullptr) {
+                continue;
+            }
         }
 
         // Get the section name and check if it's .rodata
         const char* name = elfData.ffelf_strptr(elf, shstrndx, shdr64 ? shdr64->sh_name : shdr32->sh_name);
-        if (name == NULL || !ffStrEquals(name, ".rodata")) continue;
+        if (name == nullptr || !ffStrEquals(name, ".rodata")) {
+            continue;
+        }
 
         // Get the section data
-        Elf_Data* data = elfData.ffelf_getdata(scn, NULL);
-        if (data == NULL) continue;
+        Elf_Data* data = elfData.ffelf_getdata(scn, nullptr);
+        if (data == nullptr) {
+            continue;
+        }
 
         // Scan the section for string literals
-        for (size_t off = 0; off < data->d_size; ++off)
-        {
+        for (size_t off = 0; off < data->d_size; ++off) {
             const char* p = (const char*) data->d_buf + off;
-            if (*p == '\0') continue;
-            uint32_t len = (uint32_t) strlen(p);
-            if (len < minLength) continue;
+            if (*p == '\0') {
+                continue;
+            }
+            uint32_t len = (uint32_t) strnlen(p, data->d_size - off);
+            if (len < minLength) {
+                off += len;
+                continue;
+            }
             // Only process printable ASCII characters
             if (*p >= ' ' && *p <= '~') // Ignore control characters
             {
-                if (!cb(p, len, userdata)) break;
+                if (!cb(p, len, userdata)) {
+                    break;
+                }
             }
             off += len;
         }
@@ -117,7 +131,7 @@ const char* ffBinaryExtractStrings(const char* elfFile, bool (*cb)(const char* s
     }
 
     elfData.ffelf_end(elf);
-    return NULL;
+    return nullptr;
 }
 
 #else
@@ -125,8 +139,7 @@ const char* ffBinaryExtractStrings(const char* elfFile, bool (*cb)(const char* s
 /**
  * Fallback implementation when libelf is not available
  */
-const char* ffBinaryExtractStrings(const char* file, bool (*cb)(const char* str, uint32_t len, void* userdata), void* userdata, uint32_t minLength)
-{
+const char* ffBinaryExtractStrings(const char* file, bool (*cb)(const char* str, uint32_t len, void* userdata), void* userdata, uint32_t minLength) {
     FF_UNUSED(file, cb, userdata, minLength);
     return "Fastfetch was built without libelf support";
 }

src/common/impl/binary_windows.c

@@ -1,6 +1,6 @@
 #include "common/binary.h"
 #include "common/io.h"
-#include "common/stringUtils.h"
+#include "common/strutil.h"
 #include "common/windows/nt.h"
 
 #include <windows.h>
@@ -14,53 +14,58 @@
  * (which typically contains string literals), and scans it for valid strings.
  * Each string found is passed to the callback function for processing.
  */
-const char* ffBinaryExtractStrings(const char *peFile, bool (*cb)(const char *str, uint32_t len, void *userdata), void *userdata, uint32_t minLength)
-{
-    FF_AUTO_CLOSE_FD HANDLE hFile = CreateFileA(peFile, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
-        NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
-    if (hFile == INVALID_HANDLE_VALUE)
+const char* ffBinaryExtractStrings(const char* peFile, bool (*cb)(const char* str, uint32_t len, void* userdata), void* userdata, uint32_t minLength) {
+    FF_AUTO_CLOSE_FD HANDLE hFile = CreateFileA(peFile, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
+    if (hFile == INVALID_HANDLE_VALUE) {
         return "CreateFileA() failed";
+    }
 
-    FF_AUTO_CLOSE_FD HANDLE hMap = CreateFileMappingW(hFile, NULL, PAGE_READONLY, 0, 0, NULL);
-    if (!hMap)
-        return "CreateFileMappingW() failed";
+    FF_AUTO_CLOSE_FD HANDLE hSection = nullptr;
+    if (!NT_SUCCESS(NtCreateSection(&hSection, SECTION_MAP_READ, nullptr, nullptr, PAGE_READONLY, SEC_COMMIT, hFile))) {
+        return "NtCreateSection() failed";
+    }
 
-    void* base = MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0);
-    if (!base)
-        return "MapViewOfFile() failed";
+    PVOID base = nullptr;
+    SIZE_T viewSize = 0;
+    if (!NT_SUCCESS(NtMapViewOfSection(hSection, NtCurrentProcess(), &base, 0, 0, nullptr, &viewSize, ViewUnmap, 0, PAGE_READONLY))) {
+        return "NtMapViewOfSection() failed";
+    }
 
     PIMAGE_NT_HEADERS ntHeaders = RtlImageNtHeader(base);
-    if (!ntHeaders)
-    {
-        UnmapViewOfFile(base);
+    if (!ntHeaders) {
+        NtUnmapViewOfSection(NtCurrentProcess(), base);
         return "RtlImageNtHeader() failed";
     }
 
     PIMAGE_SECTION_HEADER section = IMAGE_FIRST_SECTION(ntHeaders);
-    for (WORD i = 0; i < ntHeaders->FileHeader.NumberOfSections; ++i, ++section)
-    {
+    for (WORD i = 0; i < ntHeaders->FileHeader.NumberOfSections; ++i, ++section) {
         // Look for initialized data sections with the name ".rdata" which typically contains string literals
-        if ((section->Characteristics & IMAGE_SCN_CNT_INITIALIZED_DATA) && ffStrEquals((const char*) section->Name, ".rdata"))
-        {
-            uint8_t *data = (uint8_t *) base + section->PointerToRawData;
+        if ((section->Characteristics & IMAGE_SCN_CNT_INITIALIZED_DATA) && ffStrEquals((const char*) section->Name, ".rdata")) {
+            uint8_t* data = (uint8_t*) base + section->PointerToRawData;
 
             // Scan the section for string literals
-            for (size_t off = 0; off < section->SizeOfRawData; ++off)
-            {
+            for (size_t off = 0; off < section->SizeOfRawData; ++off) {
                 const char* p = (const char*) data + off;
-                if (*p == '\0') continue;
-                uint32_t len = (uint32_t) strlen(p);
-                if (len < minLength) continue;
+                if (*p == '\0') {
+                    continue;
+                }
+                uint32_t len = (uint32_t) strnlen(p, section->SizeOfRawData - off);
+                if (len < minLength) {
+                    off += len;
+                    continue;
+                }
                 // Only process printable ASCII characters
                 if (*p >= ' ' && *p <= '~') // Ignore control characters
                 {
-                    if (!cb(p, len, userdata)) break;
+                    if (!cb(p, len, userdata)) {
+                        break;
+                    }
                 }
                 off += len;
             }
         }
     }
 
-    UnmapViewOfFile(base);
-    return NULL;
+    NtUnmapViewOfSection(NtCurrentProcess(), base);
+    return nullptr;
 }

src/common/impl/commandoption.c

@@ -3,23 +3,24 @@
 #include "common/printing.h"
 #include "common/time.h"
 #include "common/jsonconfig.h"
-#include "common/stringUtils.h"
+#include "common/strutil.h"
 #include "fastfetch_datatext.h"
 #include "modules/modules.h"
 
 #include <ctype.h>
 #include <inttypes.h>
 
-bool ffParseModuleOptions(const char* key, const char* value)
-{
-    if (!ffStrStartsWith(key, "--") || !ffCharIsEnglishAlphabet(key[2])) return false;
-    if (value && !*value) value = NULL;
-    for (FFModuleBaseInfo** modules = ffModuleInfos[toupper(key[2]) - 'A']; *modules; ++modules)
-    {
+bool ffParseModuleOptions(const char* key, const char* value) {
+    if (!ffStrStartsWith(key, "--") || !ffCharIsEnglishAlphabet(key[2])) {
+        return false;
+    }
+    if (value && !*value) {
+        value = nullptr;
+    }
+    for (FFModuleBaseInfo** modules = ffModuleInfos[toupper(key[2]) - 'A']; *modules; ++modules) {
         FFModuleBaseInfo* baseInfo = *modules;
         const char* subKey = ffOptionTestPrefix(key, baseInfo->name);
-        if (subKey != NULL)
-        {
+        if (subKey != nullptr) {
             if (subKey[0] == '\0' || subKey[0] == '-') // Key is exactly the module name or has a leading '-'
             {
                 fprintf(stderr, "Error: unknown module key %s\n", key);
@@ -31,32 +32,25 @@ bool ffParseModuleOptions(const char* key, const char* value)
 
             FF_STRBUF_AUTO_DESTROY jsonKey = ffStrbufCreate();
             bool flag = false;
-            for (const char* p = subKey; *p; ++p)
-            {
-                if (*p == '-')
-                {
-                    if (flag)
-                    {
+            for (const char* p = subKey; *p; ++p) {
+                if (*p == '-') {
+                    if (flag) {
                         fprintf(stderr, "Error: invalid double `-` in module key %s\n", key);
                         exit(477);
                     }
                     flag = true;
-                }
-                else
-                {
-                    if (!isalpha((unsigned char)*p) && !isdigit((unsigned char)*p))
-                    {
+                } else {
+                    if (!isalpha((unsigned char) *p) && !isdigit((unsigned char) *p)) {
                         fprintf(stderr, "Error: invalid character `%c` in module key %s\n", *p, key);
                         exit(477);
                     }
 
-                    if (flag)
-                    {
+                    if (flag) {
                         flag = false;
                         ffStrbufAppendC(&jsonKey, (char) toupper((unsigned char) *p));
-                    }
-                    else
+                    } else {
                         ffStrbufAppendC(&jsonKey, *p);
+                    }
                 }
             }
             fprintf(stderr, "Error: Unsupported module option: %s\n", key);
@@ -69,188 +63,204 @@ bool ffParseModuleOptions(const char* key, const char* value)
     return false;
 }
 
-void ffPrepareCommandOption(FFdata* data)
-{
-    char* moduleType = NULL;
+void ffPrepareCommandOption(FFdata* data) {
+    char* moduleType = nullptr;
     size_t moduleLen = 0;
-    while (ffStrbufGetdelim(&moduleType, &moduleLen, ':', &data->structure))
-    {
-        #define FF_IF_MODULE_MATCH(moduleNameConstant) if (moduleLen == strlen(moduleNameConstant) \
-            && ffStrEqualsIgnCase(moduleType, moduleNameConstant) \
-            && !ffStrbufSeparatedContainIgnCaseS(&data->structureDisabled, moduleNameConstant, ':'))
+    while (ffStrbufGetdelim(&moduleType, &moduleLen, ':', &data->structure)) {
+#define FF_IF_MODULE_MATCH(moduleNameConstant) if (ffStrEqualsIgnCase(moduleType, moduleNameConstant) && !ffStrbufSeparatedContainIgnCaseS(&data->structureDisabled, moduleNameConstant, ':'))
 
-        switch (moduleType[0])
-        {
-            case 'C': case 'c':
-                FF_IF_MODULE_MATCH(FF_CPUUSAGE_MODULE_NAME)
-                    ffPrepareCPUUsage();
+        switch (moduleType[0]) {
+            #if !FF_MODULE_DISABLE_CPUUSAGE
+            case 'C':
+            case 'c':
+                FF_IF_MODULE_MATCH(ffCPUUsageModuleInfo.name)
+                ffPrepareCPUUsage();
                 break;
+            #endif
 
-            case 'D': case 'd':
-                FF_IF_MODULE_MATCH(FF_DISKIO_MODULE_NAME)
-                {
-                    __attribute__((__cleanup__(ffDestroyDiskIOOptions))) FFDiskIOOptions options;
+            #if !FF_MODULE_DISABLE_DISKIO
+            case 'D':
+            case 'd':
+                FF_IF_MODULE_MATCH(ffDiskIOModuleInfo.name) {
+                    [[gnu::cleanup(ffDestroyDiskIOOptions)]] FFDiskIOOptions options;
                     ffInitDiskIOOptions(&options);
                     ffPrepareDiskIO(&options);
                 }
                 break;
+            #endif
 
-            case 'N': case 'n':
-                FF_IF_MODULE_MATCH(FF_NETIO_MODULE_NAME)
-                {
-                    __attribute__((__cleanup__(ffDestroyNetIOOptions))) FFNetIOOptions options;
+            #if !FF_MODULE_DISABLE_NETIO
+            case 'N':
+            case 'n':
+                FF_IF_MODULE_MATCH(ffNetIOModuleInfo.name) {
+                    [[gnu::cleanup(ffDestroyNetIOOptions)]] FFNetIOOptions options;
                     ffInitNetIOOptions(&options);
                     ffPrepareNetIO(&options);
                 }
                 break;
+            #endif
 
-            case 'P': case 'p':
-                FF_IF_MODULE_MATCH(FF_PUBLICIP_MODULE_NAME)
-                {
-                    __attribute__((__cleanup__(ffDestroyPublicIpOptions))) FFPublicIPOptions options;
+            #if !FF_MODULE_DISABLE_PUBLICIP
+            case 'P':
+            case 'p':
+                FF_IF_MODULE_MATCH(ffPublicIPModuleInfo.name) {
+                    [[gnu::cleanup(ffDestroyPublicIpOptions)]] FFPublicIPOptions options;
                     ffInitPublicIpOptions(&options);
                     ffPreparePublicIp(&options);
                 }
                 break;
+            #endif
 
-            case 'W': case 'w':
-                FF_IF_MODULE_MATCH(FF_WEATHER_MODULE_NAME)
-                {
-                    __attribute__((__cleanup__(ffDestroyWeatherOptions))) FFWeatherOptions options;
+            #if !FF_MODULE_DISABLE_TOP
+            case 'T':
+            case 't':
+                FF_IF_MODULE_MATCH(ffTopModuleInfo.name) {
+                    [[gnu::cleanup(ffDestroyTopOptions)]] FFTopOptions options;
+                    ffInitTopOptions(&options);
+                    ffPrepareTopProcesses(options.showTypes);
+                }
+                break;
+            #endif
+
+            #if !FF_MODULE_DISABLE_WEATHER
+            case 'W':
+            case 'w':
+                FF_IF_MODULE_MATCH(ffWeatherModuleInfo.name) {
+                    [[gnu::cleanup(ffDestroyWeatherOptions)]] FFWeatherOptions options;
                     ffInitWeatherOptions(&options);
                     ffPrepareWeather(&options);
                 }
                 break;
+            #endif
         }
 
-        #undef FF_IF_MODULE_MATCH
+#undef FF_IF_MODULE_MATCH
     }
 }
 
-static void genJsonConfig(FFdata* data, FFModuleBaseInfo* baseInfo, void* options)
-{
+static void genJsonConfig(FFdata* data, FFModuleBaseInfo* baseInfo, void* options) {
     yyjson_mut_doc* doc = data->resultDoc;
 
     yyjson_mut_val* modules = yyjson_mut_obj_get(doc->root, "modules");
-    if (!modules)
+    if (!modules) {
         modules = yyjson_mut_obj_add_arr(doc, doc->root, "modules");
+    }
 
     FF_STRBUF_AUTO_DESTROY type = ffStrbufCreateS(baseInfo->name);
     ffStrbufLowerCase(&type);
 
-    if (data->docType == FF_RESULT_DOC_TYPE_CONFIG_FULL)
-    {
+    if (data->docType == FF_RESULT_DOC_TYPE_CONFIG_FULL) {
         yyjson_mut_val* module = yyjson_mut_obj(doc);
         yyjson_mut_obj_add_strbuf(doc, module, "type", &type);
 
-        if (baseInfo->generateJsonConfig)
+        if (baseInfo->generateJsonConfig) {
             baseInfo->generateJsonConfig(options, doc, module);
+        }
 
-        if (yyjson_mut_obj_size(module) > 1)
+        if (yyjson_mut_obj_size(module) > 1) {
             yyjson_mut_arr_add_val(modules, module);
-        else
+        } else {
             yyjson_mut_arr_add_strbuf(doc, modules, &type);
-    }
-    else
-    {
+        }
+    } else {
         yyjson_mut_arr_add_strbuf(doc, modules, &type);
     }
 }
 
-static void genJsonResult(FFdata* data, FFModuleBaseInfo* baseInfo, void* options)
-{
+static void genJsonResult(FFdata* data, FFModuleBaseInfo* baseInfo, void* options) {
     yyjson_mut_doc* doc = data->resultDoc;
     yyjson_mut_val* module = yyjson_mut_arr_add_obj(doc, doc->root);
     yyjson_mut_obj_add_str(doc, module, "type", baseInfo->name);
-    if (baseInfo->generateJsonResult)
+    if (baseInfo->generateJsonResult) {
         baseInfo->generateJsonResult(options, doc, module);
-    else
+    } else {
         yyjson_mut_obj_add_str(doc, module, "error", "Unsupported for JSON format");
+    }
 }
 
-static void parseStructureCommand(
+static bool parseStructureCommand(
     FFdata* data,
     const char* line,
-    void (*fn)(FFdata*, FFModuleBaseInfo* baseInfo, void* options)
-)
-{
-    if(ffCharIsEnglishAlphabet(line[0]))
-    {
-        for (FFModuleBaseInfo** modules = ffModuleInfos[toupper(line[0]) - 'A']; *modules; ++modules)
-        {
+    void (*fn)(FFdata*, FFModuleBaseInfo* baseInfo, void* options)) {
+    if (ffCharIsEnglishAlphabet(line[0])) {
+        for (FFModuleBaseInfo** modules = ffModuleInfos[toupper(line[0]) - 'A']; *modules; ++modules) {
             FFModuleBaseInfo* baseInfo = *modules;
-            if (ffStrEqualsIgnCase(line, baseInfo->name))
-            {
-                uint8_t optionBuf[FF_OPTION_MAX_SIZE];
+            if (ffStrEqualsIgnCase(line, baseInfo->name)) {
+                alignas(uint64_t) uint8_t optionBuf[FF_OPTION_MAX_SIZE];
                 baseInfo->initOptions(optionBuf);
-                if (__builtin_expect(data->resultDoc != NULL, false))
+                if (data->resultDoc != nullptr) {
                     fn(data, baseInfo, optionBuf);
-                else
+                } else {
                     baseInfo->printModule(optionBuf);
+                }
                 baseInfo->destroyOptions(optionBuf);
-                return;
+                return true;
             }
         }
     }
 
-    ffPrintError(line, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "<no implementation provided>");
+    if (data->resultDoc) {
+        yyjson_mut_doc* doc = data->resultDoc;
+        yyjson_mut_val* module = yyjson_mut_arr_add_obj(doc, doc->root);
+        yyjson_mut_obj_add_str(doc, module, "type", line);
+        yyjson_mut_obj_add_str(doc, module, "error", "Unknown module type");
+    } else {
+        ffPrintError(line, 0, nullptr, FF_PRINT_TYPE_NO_CUSTOM_KEY, "<no implementation provided>");
+    }
+    return false;
 }
 
-void ffPrintCommandOption(FFdata* data)
-{
-    //Parse the structure and call the modules
+void ffPrintCommandOption(FFdata* data) {
+    // Parse the structure and call the modules
     int32_t thres = instance.config.display.stat;
 
-    char* moduleType = NULL;
+    char* moduleType = nullptr;
     size_t moduleLen = 0;
-    while (ffStrbufGetdelim(&moduleType, &moduleLen, ':', &data->structure))
-    {
-        if (ffStrbufSeparatedContainIgnCaseS(&data->structureDisabled, moduleType, ':'))
+    while (ffStrbufGetdelim(&moduleType, &moduleLen, ':', &data->structure)) {
+        if (ffStrbufSeparatedContainIgnCaseS(&data->structureDisabled, moduleType, ':')) {
             continue;
+        }
 
         double ms = 0;
-        if(thres >= 0)
+        if (thres >= 0) {
             ms = ffTimeGetTick();
+        }
 
         parseStructureCommand(data, moduleType, genJsonResult);
 
-        if(thres >= 0)
-        {
+        if (thres >= 0) {
             ms = ffTimeGetTick() - ms;
 
-            if (data->resultDoc)
-            {
+            if (data->resultDoc) {
                 yyjson_mut_val* moduleJson = yyjson_mut_arr_get_last(data->resultDoc->root);
                 yyjson_mut_obj_add_real(data->resultDoc, moduleJson, "stat", ms);
-            }
-            else
-            {
+            } else {
                 char str[64];
                 int len = snprintf(str, sizeof str, "%.3fms", ms);
-                if (thres > 0)
-                    snprintf(str, sizeof str, "\e[%sm%.3fms\e[m", (ms <= thres ? FF_COLOR_FG_GREEN : ms <= 2 * thres ? FF_COLOR_FG_YELLOW : FF_COLOR_FG_RED), ms);
-                printf("\e7\e[1A\e[9999999C\e[%dD%s\e8", len, str); // Save; Up 1; Right 9999999; Left <len>; Print <str>; Load
+                if (thres > 0) {
+                    snprintf(str, sizeof str, "\e[%sm%.3fms\e[m", (ms <= thres ? FF_COLOR_FG_GREEN : ms <= 2 * thres ? FF_COLOR_FG_YELLOW
+                                                                                                                     : FF_COLOR_FG_RED),
+                        ms);
+                }
+                printf("\e7\e[1A\e[9999999C\e[%dD%s\e8", len - 1, str); // Save; Up 1; Right 9999999; Left <len - 1>; Print <str>; Load
             }
         }
 
-        #if defined(_WIN32)
-            if (!data->resultDoc && !instance.config.display.noBuffer) fflush(stdout);
-        #endif
+#if defined(_WIN32)
+        if (!data->resultDoc && !instance.config.display.noBuffer) {
+            fflush(stdout);
+        }
+#endif
     }
 }
 
-void ffMigrateCommandOptionToJsonc(FFdata* data)
-{
-    //If we don't have a custom structure, use the default one
-    if(data->structure.length == 0)
-        ffStrbufAppendS(&data->structure, FASTFETCH_DATATEXT_STRUCTURE); // Cannot use `ffStrbufSetStatic` here because we will modify the string
-
-    char* moduleType = NULL;
+void ffMigrateCommandOptionToJsonc(FFdata* data) {
+    char* moduleType = nullptr;
     size_t moduleLen = 0;
-    while (ffStrbufGetdelim(&moduleType, &moduleLen, ':', &data->structure))
-    {
-        if (ffStrbufSeparatedContainIgnCaseS(&data->structureDisabled, moduleType, ':'))
+    while (ffStrbufGetdelim(&moduleType, &moduleLen, ':', &data->structure)) {
+        if (ffStrbufSeparatedContainIgnCaseS(&data->structureDisabled, moduleType, ':')) {
             continue;
+        }
 
         parseStructureCommand(data, moduleType, genJsonConfig);
     }

src/common/impl/dbus.c

@@ -2,11 +2,10 @@
 
 #ifdef FF_HAVE_DBUS
 
-#include "common/thread.h"
-#include "common/stringUtils.h"
+    #include "common/thread.h"
+    #include "common/strutil.h"
 
-static bool loadLibSymbols(FFDBusLibrary* lib)
-{
+static bool loadLibSymbols(FFDBusLibrary* lib) {
     FF_LIBRARY_LOAD(dbus, false, "libdbus-1" FF_LIBRARY_EXTENSION, 4);
     FF_LIBRARY_LOAD_SYMBOL_PTR(dbus, lib, dbus_bus_get, false)
     FF_LIBRARY_LOAD_SYMBOL_PTR(dbus, lib, dbus_message_new_method_call, false)
@@ -20,254 +19,288 @@ static bool loadLibSymbols(FFDBusLibrary* lib)
     FF_LIBRARY_LOAD_SYMBOL_PTR(dbus, lib, dbus_message_unref, false)
     FF_LIBRARY_LOAD_SYMBOL_PTR(dbus, lib, dbus_connection_send_with_reply_and_block, false)
     FF_LIBRARY_LOAD_SYMBOL_PTR(dbus, lib, dbus_connection_unref, false)
-    dbus = NULL; // don't auto dlclose
+    dbus = nullptr; // don't auto dlclose
     return true;
 }
 
-static const FFDBusLibrary* loadLib(void)
-{
+static const FFDBusLibrary* loadLib(void) {
     static FFDBusLibrary lib;
     static bool loaded = false;
     static bool loadSuccess = false;
 
-    if(!loaded)
-    {
+    if (!loaded) {
         loaded = true;
         loadSuccess = loadLibSymbols(&lib);
     }
 
-    return loadSuccess ? &lib : NULL;
+    return loadSuccess ? &lib : nullptr;
 }
 
-const char* ffDBusLoadData(DBusBusType busType, FFDBusData* data)
-{
+const char* ffDBusLoadData(DBusBusType busType, FFDBusData* data) {
     data->lib = loadLib();
-    if(data->lib == NULL)
+    if (data->lib == nullptr) {
         return "Failed to load DBus library";
+    }
 
-    data->connection = data->lib->ffdbus_bus_get(busType, NULL);
-    if(data->connection == NULL)
+    data->connection = data->lib->ffdbus_bus_get(busType, nullptr);
+    if (data->connection == nullptr) {
         return "Failed to connect to DBus";
+    }
 
-    return NULL;
+    return nullptr;
 }
 
-void ffDBusDestroyData(FFDBusData* data)
-{
-    if (data->connection != NULL)
-    {
+void ffDBusDestroyData(FFDBusData* data) {
+    if (data->connection != nullptr) {
         data->lib->ffdbus_connection_unref(data->connection);
-        data->connection = NULL;
+        data->connection = nullptr;
     }
 }
 
-bool ffDBusGetString(FFDBusData* dbus, DBusMessageIter* iter, FFstrbuf* result)
-{
+bool ffDBusGetString(FFDBusData* dbus, DBusMessageIter* iter, FFstrbuf* result) {
     int argType = dbus->lib->ffdbus_message_iter_get_arg_type(iter);
 
-    if(argType == DBUS_TYPE_STRING || argType == DBUS_TYPE_OBJECT_PATH)
-    {
-        const char* value = NULL;
+    if (argType == DBUS_TYPE_STRING || argType == DBUS_TYPE_OBJECT_PATH) {
+        const char* value = nullptr;
         dbus->lib->ffdbus_message_iter_get_basic(iter, &value);
 
-        if(!ffStrSet(value))
+        if (!ffStrSet(value)) {
             return false;
+        }
 
         ffStrbufAppendS(result, value);
         return true;
     }
 
-    if (argType == DBUS_TYPE_BYTE)
-    {
+    if (argType == DBUS_TYPE_BYTE) {
         uint8_t value;
         dbus->lib->ffdbus_message_iter_get_basic(iter, &value);
         ffStrbufAppendC(result, (char) value);
-        return false; // Don't append a comma
+        return true;
     }
 
-    if(argType != DBUS_TYPE_VARIANT && argType != DBUS_TYPE_ARRAY)
+    if (argType != DBUS_TYPE_VARIANT && argType != DBUS_TYPE_ARRAY) {
         return false;
+    }
 
     DBusMessageIter subIter;
     dbus->lib->ffdbus_message_iter_recurse(iter, &subIter);
 
-    if(argType == DBUS_TYPE_VARIANT)
+    if (argType == DBUS_TYPE_VARIANT) {
         return ffDBusGetString(dbus, &subIter, result);
+    }
 
-    //At this point we have an array
+    // At this point we have an array
+
+    int subArgType = dbus->lib->ffdbus_message_iter_get_arg_type(&subIter);
+    if (subArgType == DBUS_TYPE_INVALID) {
+        return false;
+    }
+
+    if (subArgType == DBUS_TYPE_BYTE) {
+        while (true) {
+            uint8_t value;
+            dbus->lib->ffdbus_message_iter_get_basic(&subIter, &value);
+            ffStrbufAppendC(result, (char) value);
+
+            if (!dbus->lib->ffdbus_message_iter_next(&subIter)) {
+                break;
+            }
+        }
+
+        return true;
+    }
 
     bool foundAValue = false;
 
-    while(true)
-    {
-        if(ffDBusGetString(dbus, &subIter, result))
-        {
+    while (true) {
+        if (ffDBusGetString(dbus, &subIter, result)) {
             foundAValue = true;
             ffStrbufAppendS(result, ", ");
         }
 
-        if(!dbus->lib->ffdbus_message_iter_next(&subIter))
+        if (!dbus->lib->ffdbus_message_iter_next(&subIter)) {
             break;
-        else
+        } else {
             continue;
+        }
     }
 
-    if(foundAValue)
+    if (foundAValue) {
         ffStrbufSubstrBefore(result, result->length - 2);
+    }
 
     return foundAValue;
 }
 
-bool ffDBusGetBool(FFDBusData* dbus, DBusMessageIter* iter, bool* result)
-{
+bool ffDBusGetBool(FFDBusData* dbus, DBusMessageIter* iter, bool* result) {
     int argType = dbus->lib->ffdbus_message_iter_get_arg_type(iter);
 
-    if(argType == DBUS_TYPE_BOOLEAN)
-    {
+    if (argType == DBUS_TYPE_BOOLEAN) {
         dbus_bool_t value = 0;
         dbus->lib->ffdbus_message_iter_get_basic(iter, &value);
         *result = value != 0;
         return true;
     }
 
-    if(argType != DBUS_TYPE_VARIANT)
+    if (argType != DBUS_TYPE_VARIANT) {
         return false;
+    }
 
     DBusMessageIter subIter;
     dbus->lib->ffdbus_message_iter_recurse(iter, &subIter);
     return ffDBusGetBool(dbus, &subIter, result);
 }
 
-bool ffDBusGetUint(FFDBusData* dbus, DBusMessageIter* iter, uint32_t* result)
-{
+bool ffDBusGetUint(FFDBusData* dbus, DBusMessageIter* iter, uint64_t* result) {
     int argType = dbus->lib->ffdbus_message_iter_get_arg_type(iter);
 
-    if(argType == DBUS_TYPE_BYTE)
-    {
+    if (argType == DBUS_TYPE_BYTE) {
         uint8_t value = 0;
         dbus->lib->ffdbus_message_iter_get_basic(iter, &value);
         *result = value;
         return true;
     }
 
-    if(argType == DBUS_TYPE_UINT16)
-    {
+    if (argType == DBUS_TYPE_UINT16) {
         uint16_t value = 0;
         dbus->lib->ffdbus_message_iter_get_basic(iter, &value);
         *result = value;
         return true;
     }
 
-    if(argType == DBUS_TYPE_UINT32)
-    {
+    if (argType == DBUS_TYPE_UINT32) {
+        uint32_t value = 0;
+        dbus->lib->ffdbus_message_iter_get_basic(iter, &value);
+        *result = value;
+        return true;
+    }
+
+    if (argType == DBUS_TYPE_UINT64) {
         dbus->lib->ffdbus_message_iter_get_basic(iter, result);
         return true;
     }
 
-    if(argType != DBUS_TYPE_VARIANT)
+    if (argType != DBUS_TYPE_VARIANT) {
         return false;
+    }
 
     DBusMessageIter subIter;
     dbus->lib->ffdbus_message_iter_recurse(iter, &subIter);
     return ffDBusGetUint(dbus, &subIter, result);
 }
 
-bool ffDBusGetInt(FFDBusData* dbus, DBusMessageIter* iter, int32_t* result)
-{
+bool ffDBusGetInt(FFDBusData* dbus, DBusMessageIter* iter, int64_t* result) {
     int argType = dbus->lib->ffdbus_message_iter_get_arg_type(iter);
 
-    if(argType == DBUS_TYPE_INT16)
-    {
+    if (argType == DBUS_TYPE_INT16) {
         int16_t value = 0;
         dbus->lib->ffdbus_message_iter_get_basic(iter, &value);
         *result = value;
         return true;
     }
 
-    if(argType == DBUS_TYPE_INT32)
-    {
+    if (argType == DBUS_TYPE_INT32) {
+        int32_t value = 0;
+        dbus->lib->ffdbus_message_iter_get_basic(iter, &value);
+        *result = value;
+        return true;
+    }
+
+    if (argType == DBUS_TYPE_INT64) {
         dbus->lib->ffdbus_message_iter_get_basic(iter, result);
         return true;
     }
 
-    if(argType == DBUS_TYPE_BYTE)
-    {
+    if (argType == DBUS_TYPE_BYTE) {
         uint8_t value = 0;
         dbus->lib->ffdbus_message_iter_get_basic(iter, &value);
         *result = value;
         return true;
     }
 
-    if(argType == DBUS_TYPE_UINT16)
-    {
+    if (argType == DBUS_TYPE_UINT16) {
         uint16_t value = 0;
         dbus->lib->ffdbus_message_iter_get_basic(iter, &value);
-        *result = (int16_t) value;
+        *result = (int32_t) value;
         return true;
     }
 
-    if(argType == DBUS_TYPE_UINT32)
-    {
-        dbus->lib->ffdbus_message_iter_get_basic(iter, result);
+    if (argType == DBUS_TYPE_UINT32) {
+        uint32_t value = 0;
+        dbus->lib->ffdbus_message_iter_get_basic(iter, &value);
+        *result = (int32_t) value;
         return true;
     }
 
-    if(argType != DBUS_TYPE_VARIANT)
+    if (argType == DBUS_TYPE_UINT64) {
+        uint64_t value = 0;
+        dbus->lib->ffdbus_message_iter_get_basic(iter, &value);
+        if (value > INT64_MAX) {
+            return false;
+        }
+        *result = (int64_t) value;
+        return true;
+    }
+
+    if (argType != DBUS_TYPE_VARIANT) {
         return false;
+    }
 
     DBusMessageIter subIter;
     dbus->lib->ffdbus_message_iter_recurse(iter, &subIter);
     return ffDBusGetInt(dbus, &subIter, result);
 }
 
-DBusMessage* ffDBusGetMethodReply(FFDBusData* dbus, const char* busName, const char* objectPath, const char* interface, const char* method, const char* arg1, const char* arg2)
-{
+DBusMessage* ffDBusGetMethodReply(FFDBusData* dbus, const char* busName, const char* objectPath, const char* interface, const char* method, const char* arg1, const char* arg2) {
     DBusMessage* message = dbus->lib->ffdbus_message_new_method_call(busName, objectPath, interface, method);
-    if(message == NULL)
-        return NULL;
-
-    if (arg1)
-    {
-        if (arg2)
-            dbus->lib->ffdbus_message_append_args(message, DBUS_TYPE_STRING, &arg1, DBUS_TYPE_STRING, &arg2, DBUS_TYPE_INVALID);
-        else
-            dbus->lib->ffdbus_message_append_args(message, DBUS_TYPE_STRING, &arg1, DBUS_TYPE_INVALID);
+    if (message == nullptr) {
+        return nullptr;
     }
 
-    DBusMessage* reply = dbus->lib->ffdbus_connection_send_with_reply_and_block(dbus->connection, message, instance.config.general.processingTimeout, NULL);
+    if (arg1) {
+        if (arg2) {
+            dbus->lib->ffdbus_message_append_args(message, DBUS_TYPE_STRING, &arg1, DBUS_TYPE_STRING, &arg2, DBUS_TYPE_INVALID);
+        } else {
+            dbus->lib->ffdbus_message_append_args(message, DBUS_TYPE_STRING, &arg1, DBUS_TYPE_INVALID);
+        }
+    }
+
+    DBusMessage* reply = dbus->lib->ffdbus_connection_send_with_reply_and_block(dbus->connection, message, instance.config.general.processingTimeout, nullptr);
 
     dbus->lib->ffdbus_message_unref(message);
 
     return reply;
 }
 
-DBusMessage* ffDBusGetProperty(FFDBusData* dbus, const char* busName, const char* objectPath, const char* interface, const char* property)
-{
+DBusMessage* ffDBusGetProperty(FFDBusData* dbus, const char* busName, const char* objectPath, const char* interface, const char* property) {
     DBusMessage* message = dbus->lib->ffdbus_message_new_method_call(busName, objectPath, "org.freedesktop.DBus.Properties", "Get");
-    if(message == NULL)
-        return NULL;
+    if (message == nullptr) {
+        return nullptr;
+    }
 
     dbus->lib->ffdbus_message_append_args(message,
-        DBUS_TYPE_STRING, &interface,
-        DBUS_TYPE_STRING, &property,
+        DBUS_TYPE_STRING,
+        &interface,
+        DBUS_TYPE_STRING,
+        &property,
         DBUS_TYPE_INVALID);
 
-    DBusMessage* reply = dbus->lib->ffdbus_connection_send_with_reply_and_block(dbus->connection, message, instance.config.general.processingTimeout, NULL);
+    DBusMessage* reply = dbus->lib->ffdbus_connection_send_with_reply_and_block(dbus->connection, message, instance.config.general.processingTimeout, nullptr);
 
     dbus->lib->ffdbus_message_unref(message);
 
     return reply;
 }
 
-bool ffDBusGetPropertyString(FFDBusData* dbus, const char* busName, const char* objectPath, const char* interface, const char* property, FFstrbuf* result)
-{
+bool ffDBusGetPropertyString(FFDBusData* dbus, const char* busName, const char* objectPath, const char* interface, const char* property, FFstrbuf* result) {
     DBusMessage* reply = ffDBusGetProperty(dbus, busName, objectPath, interface, property);
-    if(reply == NULL)
+    if (reply == nullptr) {
         return false;
+    }
 
     DBusMessageIter rootIterator;
-    if(!dbus->lib->ffdbus_message_iter_init(reply, &rootIterator))
-    {
+    if (!dbus->lib->ffdbus_message_iter_init(reply, &rootIterator)) {
         dbus->lib->ffdbus_message_unref(reply);
         return false;
     }
@@ -279,15 +312,14 @@ bool ffDBusGetPropertyString(FFDBusData* dbus, const char* busName, const char*
     return ret;
 }
 
-bool ffDBusGetPropertyUint(FFDBusData* dbus, const char* busName, const char* objectPath, const char* interface, const char* property, uint32_t* result)
-{
+bool ffDBusGetPropertyUint(FFDBusData* dbus, const char* busName, const char* objectPath, const char* interface, const char* property, uint64_t* result) {
     DBusMessage* reply = ffDBusGetProperty(dbus, busName, objectPath, interface, property);
-    if(reply == NULL)
+    if (reply == nullptr) {
         return false;
+    }
 
     DBusMessageIter rootIterator;
-    if(!dbus->lib->ffdbus_message_iter_init(reply, &rootIterator))
-    {
+    if (!dbus->lib->ffdbus_message_iter_init(reply, &rootIterator)) {
         dbus->lib->ffdbus_message_unref(reply);
         return false;
     }
@@ -299,4 +331,4 @@ bool ffDBusGetPropertyUint(FFDBusData* dbus, const char* busName, const char* ob
     return ret;
 }
 
-#endif //FF_HAVE_DBUS
+#endif // FF_HAVE_DBUS

src/common/impl/debug_windows.c

@@ -1,28 +1,60 @@
 #include "common/debug.h"
+#include "common/windows/nt.h"
 
 #include <windows.h>
+#include <cfgmgr32.h>
 
-const char* ffDebugWin32Error(DWORD errorCode)
-{
-    static char buffer[256];
+const char* ffDebugWin32Error(DWORD errorCode) {
+    static char buffer[512];
 
-    DWORD len = FormatMessageA(
+    wchar_t bufferW[256];
+    ULONG len = FormatMessageW(
         FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
-        NULL,
+        nullptr,
         (DWORD) errorCode,
-        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-        buffer,
-        sizeof(buffer),
-        NULL);
+        0,
+        bufferW,
+        ARRAY_SIZE(bufferW),
+        nullptr);
 
     if (len == 0) {
         snprintf(buffer, sizeof(buffer), "Unknown error code (%lu)", errorCode);
     } else {
         // Remove trailing newline
-        if (buffer[len - 1] == '\n') buffer[len - 1] = '\0';
-        if (buffer[len - 2] == '\r') buffer[len - 2] = '\0';
-        snprintf(buffer + len - 2, sizeof(buffer) - len + 2, " (%lu)", errorCode);
+        while (len > 0 && (bufferW[len - 1] == '\r' || bufferW[len - 1] == '\n')) {
+            --len;
+        }
+
+        if (NT_SUCCESS(RtlUnicodeToUTF8N(buffer, sizeof(buffer), &len, bufferW, len * sizeof(wchar_t)))) {
+            snprintf(buffer + len, sizeof(buffer) - len, " (%lu)", errorCode);
+        } else {
+            snprintf(buffer, sizeof(buffer), "Unknown error (%lu)", errorCode);
+        }
     }
 
     return buffer;
 }
+
+const char* ffDebugConfigRet(CONFIGRET ret) {
+    return ffDebugWin32Error(CM_MapCrToWin32Err(ret, ERROR_INTERNAL_ERROR));
+}
+
+const char* ffDebugNtStatus(NTSTATUS status) {
+    return ffDebugWin32Error(RtlNtStatusToDosError(status));
+}
+
+static inline DWORD HRESULTToWin32Error(HRESULT hr) {
+    if (SUCCEEDED(hr)) {
+        return ERROR_SUCCESS;
+    }
+
+    if (HRESULT_FACILITY(hr) == FACILITY_WIN32) {
+        return HRESULT_CODE(hr);
+    }
+
+    return ERROR_INTERNAL_ERROR;
+}
+
+const char* ffDebugHResult(HRESULT hr) {
+    return ffDebugWin32Error(HRESULTToWin32Error(hr));
+}

src/common/impl/duration.c

@@ -1,25 +1,27 @@
 #include "common/duration.h"
 
-void ffDurationAppendNum(uint64_t totalSeconds, FFstrbuf* result)
-{
+void ffDurationAppendNum(uint64_t totalSeconds, FFstrbuf* result) {
     const FFOptionsDisplay* options = &instance.config.display;
 
     bool spaceBeforeUnit = options->durationSpaceBeforeUnit != FF_SPACE_BEFORE_UNIT_NEVER;
 
-    if (totalSeconds < 60)
-    {
+    if (totalSeconds < 60) {
         ffStrbufAppendUInt(result, totalSeconds);
-        if (spaceBeforeUnit) ffStrbufAppendC(result, ' ');
+        if (spaceBeforeUnit) {
+            ffStrbufAppendC(result, ' ');
+        }
         ffStrbufAppendS(result, options->durationAbbreviation ? "sec" : "second");
-        if (totalSeconds != 1)
+        if (totalSeconds != 1) {
             ffStrbufAppendC(result, 's');
+        }
         return;
     }
 
     uint32_t seconds = (uint32_t) (totalSeconds % 60);
     totalSeconds /= 60;
-    if (seconds >= 30)
+    if (seconds >= 30) {
         totalSeconds++;
+    }
 
     uint32_t minutes = (uint32_t) (totalSeconds % 60);
     totalSeconds /= 60;
@@ -27,56 +29,59 @@ void ffDurationAppendNum(uint64_t totalSeconds, FFstrbuf* result)
     totalSeconds /= 24;
     uint32_t days = (uint32_t) totalSeconds;
 
-    if (days > 0)
-    {
+    if (days > 0) {
         ffStrbufAppendUInt(result, days);
-        if (spaceBeforeUnit) ffStrbufAppendC(result, ' ');
-        if (options->durationAbbreviation)
-        {
+        if (spaceBeforeUnit) {
+            ffStrbufAppendC(result, ' ');
+        }
+        if (options->durationAbbreviation) {
             ffStrbufAppendC(result, 'd');
 
-            if (hours > 0 || minutes > 0)
+            if (hours > 0 || minutes > 0) {
                 ffStrbufAppendC(result, ' ');
-        }
-        else
-        {
+            }
+        } else {
             ffStrbufAppendS(result, days == 1 ? "day" : "days");
 
-            if (days >= 100)
+            if (days >= 100) {
                 ffStrbufAppendS(result, "(!)");
+            }
 
-            if (hours > 0 || minutes > 0)
+            if (hours > 0 || minutes > 0) {
                 ffStrbufAppendS(result, ", ");
+            }
         }
     }
 
-    if (hours > 0)
-    {
+    if (hours > 0) {
         ffStrbufAppendUInt(result, hours);
-        if (spaceBeforeUnit) ffStrbufAppendC(result, ' ');
-        if (options->durationAbbreviation)
-        {
+        if (spaceBeforeUnit) {
+            ffStrbufAppendC(result, ' ');
+        }
+        if (options->durationAbbreviation) {
             ffStrbufAppendC(result, 'h');
 
-            if (minutes > 0)
+            if (minutes > 0) {
                 ffStrbufAppendC(result, ' ');
-        }
-        else
-        {
+            }
+        } else {
             ffStrbufAppendS(result, hours == 1 ? "hour" : "hours");
 
-            if (minutes > 0)
+            if (minutes > 0) {
                 ffStrbufAppendS(result, ", ");
+            }
         }
     }
 
-    if (minutes > 0)
-    {
+    if (minutes > 0) {
         ffStrbufAppendUInt(result, minutes);
-        if (spaceBeforeUnit) ffStrbufAppendC(result, ' ');
-        if (options->durationAbbreviation)
+        if (spaceBeforeUnit) {
+            ffStrbufAppendC(result, ' ');
+        }
+        if (options->durationAbbreviation) {
             ffStrbufAppendC(result, 'm');
-        else
+        } else {
             ffStrbufAppendS(result, minutes == 1 ? "min" : "mins");
+        }
     }
 }

src/common/impl/edidHelper.c

@@ -1,55 +1,39 @@
 #include "common/edidHelper.h"
 
-void ffEdidGetPhysicalResolution(const uint8_t edid[128], uint32_t* width, uint32_t* height)
-{
+void ffEdidGetPhysicalResolution(const uint8_t edid[128], uint32_t* width, uint32_t* height) {
     const int dtd = 54;
     *width = (((uint32_t) edid[dtd + 4] >> 4) << 8) | edid[dtd + 2];
     *height = (((uint32_t) edid[dtd + 7] >> 4) << 8) | edid[dtd + 5];
 }
 
-void ffEdidGetPreferredResolutionAndRefreshRate(const uint8_t edid[128], uint32_t* width, uint32_t* height, double* refreshRate)
-{
-    for (uint32_t i = 0x36; i < 0x7E; i += 0x12)
-    { // read through descriptor blocks...
-        if (edid[i] != 0x00 && edid[i + 1] != 0x00)
-        { // a dtd
-            uint32_t hactive = edid[i+2] + (uint32_t) ((edid[i + 4] & 0xf0) << 4);
-            uint32_t hblank = edid[i+3] + (uint32_t) ((edid[i + 4] & 0x0f) << 8);
-            uint32_t vactive = edid[i+5] + (uint32_t) ((edid[i + 7] & 0xf0) << 4);
-            uint32_t vblank = edid[i+6] + (uint32_t) ((edid[i + 7] & 0x0f) << 8);
-            uint32_t pixclk = ((uint32_t) edid[i+1] << 8) | (edid[i]);
+void ffEdidGetPreferredResolutionAndRefreshRate(const uint8_t edid[128], uint32_t* width, uint32_t* height, double* refreshRate) {
+    for (uint32_t i = 0x36; i < 0x7E; i += 0x12) {    // read through descriptor blocks...
+        if (edid[i] != 0x00 && edid[i + 1] != 0x00) { // a dtd
+            uint32_t hactive = edid[i + 2] + (uint32_t) ((edid[i + 4] & 0xf0) << 4);
+            uint32_t hblank = edid[i + 3] + (uint32_t) ((edid[i + 4] & 0x0f) << 8);
+            uint32_t vactive = edid[i + 5] + (uint32_t) ((edid[i + 7] & 0xf0) << 4);
+            uint32_t vblank = edid[i + 6] + (uint32_t) ((edid[i + 7] & 0x0f) << 8);
+            uint32_t pixclk = ((uint32_t) edid[i + 1] << 8) | (edid[i]);
             *width = hactive;
             *height = vactive;
-            *refreshRate = (double)pixclk * 10000 / (double)(hactive+hblank) / (double)(vactive+vblank);
+            *refreshRate = (double) pixclk * 10000 / (double) (hactive + hblank) / (double) (vactive + vblank);
             return;
         }
     }
 }
 
-void ffEdidGetVendorAndModel(const uint8_t edid[128], FFstrbuf* result)
-{
+void ffEdidGetVendorAndModel(const uint8_t edid[128], FFstrbuf* result) {
     // https://github.com/jinksong/read_edid/blob/master/parse-edid/parse-edid.c
-    ffStrbufAppendF(result, "%c%c%c%04X",
-        (char) (((uint32_t)edid[8] >> 2 & 0x1f) + 'A' - 1),
-        (char) (((((uint32_t)edid[8] & 0x3) << 3) | (((uint32_t)edid[9] & 0xe0) >> 5)) + 'A' - 1),
-        (char) (((uint32_t)edid[9] & 0x1f) + 'A' - 1),
-        (uint32_t) (edid[10] + (uint32_t) (edid[11] << 8))
-    );
+    ffStrbufAppendF(result, "%c%c%c%04X", (char) (((uint32_t) edid[8] >> 2 & 0x1f) + 'A' - 1), (char) (((((uint32_t) edid[8] & 0x3) << 3) | (((uint32_t) edid[9] & 0xe0) >> 5)) + 'A' - 1), (char) (((uint32_t) edid[9] & 0x1f) + 'A' - 1), (uint32_t) (edid[10] + (uint32_t) (edid[11] << 8)));
 }
 
-bool ffEdidGetName(const uint8_t edid[128], FFstrbuf* name)
-{
+bool ffEdidGetName(const uint8_t edid[128], FFstrbuf* name) {
     // https://github.com/jinksong/read_edid/blob/master/parse-edid/parse-edid.c
-    for (uint32_t i = 0x36; i < 0x7E; i += 0x12)
-    { // read through descriptor blocks...
-        if (edid[i] == 0x00)
-        { // not a timing descriptor
-            if (edid[i + 3] == 0xfc)
-            { // Model Name tag
-                for (uint32_t j = 0; j < 13; j++)
-                {
-                    if (edid[i + 5 + j] == 0x0a)
-                    {
+    for (uint32_t i = 0x36; i < 0x7E; i += 0x12) { // read through descriptor blocks...
+        if (edid[i] == 0x00) {                     // not a timing descriptor
+            if (edid[i + 3] == 0xfc) {             // Model Name tag
+                for (uint32_t j = 0; j < 13; j++) {
+                    if (edid[i + 5 + j] == 0x0a) {
                         ffStrbufAppendNS(name, j, (const char*) &edid[i + 5]);
                         return true;
                     }
@@ -63,8 +47,7 @@ bool ffEdidGetName(const uint8_t edid[128], FFstrbuf* name)
     return false;
 }
 
-void ffEdidGetPhysicalSize(const uint8_t edid[128], uint32_t* width, uint32_t* height)
-{
+void ffEdidGetPhysicalSize(const uint8_t edid[128], uint32_t* width, uint32_t* height) {
     // Detailed Timing Descriptors
     uint32_t dw = (((uint32_t) edid[68] & 0xF0) << 4) + edid[66];
     uint32_t dh = (((uint32_t) edid[68] & 0x0F) << 8) + edid[67];
@@ -74,53 +57,95 @@ void ffEdidGetPhysicalSize(const uint8_t edid[128], uint32_t* width, uint32_t* h
     uint32_t bh = edid[22] * 10;
 
     // Some monitors report invalid data in DTD. See #1406
-    if (abs((int)dw - (int)bw) < 10 && abs((int)dh - (int)bh) < 10)
-    {
+    if (abs((int) dw - (int) bw) < 10 && abs((int) dh - (int) bh) < 10) {
         *width = dw;
         *height = dh;
-    }
-    else
-    {
+    } else {
         *width = bw;
         *height = bh;
     }
 }
 
-void ffEdidGetSerialAndManufactureDate(const uint8_t edid[128], uint32_t* serial, uint16_t* year, uint16_t* week)
-{
-    if (edid[17] > 0 && edid[17] < 0xFF)
-    {
+void ffEdidGetManufactureDate(const uint8_t edid[128], uint16_t* year, uint16_t* week) {
+    if (edid[17] > 0 && edid[17] < 0xFF) {
         *year = (uint16_t) (edid[17] + 1990);
         *week = (uint16_t) edid[16];
-        if (*week == 0xFF) *week = 0;
-    }
-    else
+        if (*week == 0xFF) {
+            *week = 0;
+        }
+    } else {
         *year = *week = 0;
-
-    *serial = *(uint32_t*) &edid[12];
+    }
 }
 
-bool ffEdidGetHdrCompatible(const uint8_t* edid, uint32_t length)
-{
-    if (length <= 128) return false;
-    for (const uint8_t* cta = &edid[128]; cta < &edid[length]; cta += 128)
-    {
+bool ffEdidGetSerial(const uint8_t edid[128], FFstrbuf* result) {
+    int descriptor_offsets[4] = {54, 72, 90, 108};
+
+    for (int i = 0; i < 4; i++) {
+        int offset = descriptor_offsets[i];
+        const uint8_t* desc = edid + offset;
+
+        if (desc[0] == 0x00 && desc[1] == 0x00) { // Monitor Descriptor
+            uint8_t tag = desc[3]; // Descriptor Type Tag
+
+            if (tag == 0xFF) { // Display Product Serial Number
+                ffStrbufClear(result);
+                for (int j = 0; j < 13; j++) {
+                    uint8_t ch = desc[5 + j];
+
+                    if (ch == 0x0A || ch == 0x00) {
+                        break;
+                    }
+
+                    ffStrbufAppendC(result, (char) ch);
+                }
+
+                ffStrbufTrim(result, ' ');
+                if (result->length > 0) {
+                    return true;
+                }
+            }
+        }
+    }
+
+    uint32_t int_serial = 0;
+    int_serial |= (uint32_t)edid[12];
+    int_serial |= (uint32_t)edid[13] << 8;
+    int_serial |= (uint32_t)edid[14] << 16;
+    int_serial |= (uint32_t)edid[15] << 24;
+
+    if (int_serial != 0 && int_serial != 0xFFFFFFFF) {
+        ffStrbufSetF(result, "0x%08X", int_serial);
+        return true;
+    }
+    return false;
+}
+
+bool ffEdidGetHdrCompatible(const uint8_t* edid, uint32_t length) {
+    if (length <= 128) {
+        return false;
+    }
+    for (const uint8_t* cta = &edid[128]; cta < &edid[length]; cta += 128) {
         // https://en.wikipedia.org/wiki/Extended_Display_Identification_Data#CTA_EDID_Timing_Extension_Block
-        if (cta[0] != 0x02 /* CTA EDID */) continue;
-        if (cta[1] < 0x03 /* Version 3 */) continue;
+        if (cta[0] != 0x02 /* CTA EDID */) {
+            continue;
+        }
+        if (cta[1] < 0x03 /* Version 3 */) {
+            continue;
+        }
         const uint8_t offset = cta[2];
-        if (offset <= 4) continue;
-        for (uint8_t i = 4; i < offset;)
-        {
+        if (offset <= 4) {
+            continue;
+        }
+        for (uint8_t i = 4; i < offset;) {
             uint8_t blkLen = cta[i] & 0x1f;
-            if (blkLen > 0)
-            {
+            if (blkLen > 0) {
                 uint8_t blkTag = (cta[i] & 0xe0) >> 5;
-                if (blkTag == 0x07 /* Extended Block Type Tag */)
-                {
+                if (blkTag == 0x07 /* Extended Block Type Tag */) {
                     uint8_t extendedTag = cta[i + 1];
-                    if (extendedTag == 6 /* HDR SMDB */ || extendedTag == 7 /* HDR DMDB */)
+                    if (extendedTag == 6 /* HDR SMDB */ || extendedTag == 7 /* HDR DMDB */) {
                         return true;
+                    }
                 }
             }
             i += (uint8_t) (blkLen + 1);
@@ -128,3 +153,21 @@ bool ffEdidGetHdrCompatible(const uint8_t* edid, uint32_t length)
     }
     return false;
 }
+
+bool ffEdidIsValid(const uint8_t edid[128], uint32_t length) {
+    if (length < 128 || length % 128 != 0) {
+        return false;
+    }
+
+    static const uint8_t edidHeader[] = { 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00 };
+    if (memcmp(edid, edidHeader, sizeof(edidHeader)) != 0) {
+        return false;
+    }
+
+    uint8_t sum = 0;
+    for (uint32_t i = 0; i < 128; i++) {
+        sum += edid[i];
+    }
+
+    return sum == 0;
+}

src/common/impl/font.c

@@ -1,99 +1,104 @@
 #include "fastfetch.h"
 #include "common/FFlist.h"
 #include "common/FFstrbuf.h"
-#include "common/stringUtils.h"
+#include "common/strutil.h"
 #include "common/font.h"
 
 #include <string.h>
 #include <ctype.h>
 
-void ffFontInit(FFfont* font)
-{
+void ffFontInit(FFfont* font) {
     // Ensure no memory allocates
     ffStrbufInit(&font->pretty);
     ffStrbufInit(&font->name);
     ffStrbufInit(&font->size);
-    ffListInit(&font->styles, sizeof(FFstrbuf));
+    ffListInit(&font->styles);
 }
 
-static void strbufAppendNSExcludingC(FFstrbuf* strbuf, uint32_t length, const char* value, char exclude)
-{
-    if(value == NULL || length == 0)
+static void strbufAppendNSExcludingC(FFstrbuf* strbuf, uint32_t length, const char* value, char exclude) {
+    if (value == nullptr || length == 0) {
         return;
+    }
 
     ffStrbufEnsureFree(strbuf, length);
 
-    for(uint32_t i = 0; i < length; i++)
-    {
-        if(value[i] != exclude)
-        strbuf->chars[strbuf->length++] = value[i];
+    for (uint32_t i = 0; i < length; i++) {
+        if (value[i] != exclude) {
+            strbuf->chars[strbuf->length++] = value[i];
+        }
     }
 
     strbuf->chars[strbuf->length] = '\0';
 }
 
-static void fontInitPretty(FFfont* font)
-{
+static void fontInitPretty(FFfont* font) {
     ffStrbufAppend(&font->pretty, &font->name);
 
-    if(font->size.length == 0 && font->styles.length == 0)
+    if (font->size.length == 0 && font->styles.length == 0) {
         return;
-    else if(font->pretty.length == 0)
+    } else if (font->pretty.length == 0) {
         ffStrbufAppendS(&font->pretty, "default");
+    }
 
     ffStrbufAppendS(&font->pretty, " (");
 
-    if(font->size.length > 0)
-    {
+    if (font->size.length > 0) {
         ffStrbufAppend(&font->pretty, &font->size);
-        if (!ffStrbufEndsWithS(&font->size, "pt") && !ffStrbufEndsWithS(&font->size, "px"))
+        if (!ffStrbufEndsWithS(&font->size, "pt") && !ffStrbufEndsWithS(&font->size, "px")) {
             ffStrbufAppendS(&font->pretty, "pt");
+        }
 
-        if(font->styles.length > 0)
+        if (font->styles.length > 0) {
             ffStrbufAppendS(&font->pretty, ", ");
+        }
     }
 
-    for(uint32_t i = 0; i < font->styles.length; i++)
-    {
+    for (uint32_t i = 0; i < font->styles.length; i++) {
         ffStrbufAppend(&font->pretty, FF_LIST_GET(FFstrbuf, font->styles, i));
 
-        if(i < font->styles.length - 1)
+        if (i < font->styles.length - 1) {
             ffStrbufAppendS(&font->pretty, ", ");
+        }
     }
 
     ffStrbufAppendC(&font->pretty, ')');
 }
 
-void ffFontInitQt(FFfont* font, const char* data)
-{
+void ffFontInitQt(FFfont* font, const char* data) {
     ffFontInit(font);
 
-    //See https://doc.qt.io/qt-5/qfont.html#toString
+    // See https://doc.qt.io/qt-5/qfont.html#toString
 
-    //Family
+    // Family
     data = ffStrbufAppendSUntilC(&font->name, data, ',');
     ffStrbufTrim(&font->name, ' ');
-    if (!data) goto exit;
+    if (!data) {
+        goto exit;
+    }
     data++;
 
-    //Size
+    // Size
     data = ffStrbufAppendSUntilC(&font->size, data, ',');
     ffStrbufTrim(&font->size, ' ');
-    if (!data) goto exit;
+    if (!data) {
+        goto exit;
+    }
     data++;
 
-    //Style
+    // Style
     data = strrchr(data, ',');
-    if (!data) goto exit;
+    if (!data) {
+        goto exit;
+    }
     data++;
-    if (isalpha(*data))
-    {
-        do
-        {
-            FFstrbuf* style = (FFstrbuf*) ffListAdd(&font->styles);
+    if (isalpha(*data)) {
+        do {
+            FFstrbuf* style = FF_LIST_ADD(FFstrbuf, font->styles);
             ffStrbufInit(style);
             data = ffStrbufAppendSUntilC(style, data, ' ');
-            if (data) data++;
+            if (data) {
+                data++;
+            }
         } while (data);
     }
 
@@ -101,34 +106,37 @@ exit:
     fontInitPretty(font);
 }
 
-static void fontPangoParseWord(const char** data, FFfont* font, FFstrbuf* alternativeBuffer)
-{
-    while(**data == ' ' || **data == '\t' || **data == ',')
+static void fontPangoParseWord(const char** data, FFfont* font, FFstrbuf* alternativeBuffer) {
+    while (**data == ' ' || **data == '\t' || **data == ',') {
         ++(*data);
+    }
 
     const char* wordStart = *data;
 
-    while(**data != ' ' && **data != '\t' && **data != ',' && **data != '\0' && **data != '`' && **data != '\\')
+    while (**data != ' ' && **data != '\t' && **data != ',' && **data != '\0' && **data != '`' && **data != '\\') {
         ++(*data);
+    }
 
     uint32_t wordLength = (uint32_t) (*data - wordStart);
-    if(wordLength == 0)
+    if (wordLength == 0) {
         return;
+    }
 
-    if(**data == '\0' || **data == '`' || **data == '\\')
-    {
+    if (**data == '\0' || **data == '`' || **data == '\\') {
         ffStrbufAppendNS(&font->size, wordLength, wordStart);
-        if(ffStrbufEndsWithS(&font->size, "px"))
+        if (ffStrbufEndsWithS(&font->size, "px")) {
             ffStrbufSubstrBefore(&font->size, font->size.length - 2);
+        }
 
         double dummy;
-        if(sscanf(font->size.chars, "%lf", &dummy) == 1)
+        if (sscanf(font->size.chars, "%lf", &dummy) == 1) {
             return;
+        }
 
         ffStrbufClear(&font->size);
     }
 
-    if(
+    if (
         ffStrStartsWithIgnCase(wordStart, "Ultra") ||
         ffStrStartsWithIgnCase(wordStart, "Extra") ||
         ffStrStartsWithIgnCase(wordStart, "Semi") ||
@@ -142,51 +150,47 @@ static void fontPangoParseWord(const char** data, FFfont* font, FFstrbuf* altern
         ffStrStartsWithIgnCase(wordStart, "Bold") ||
         ffStrStartsWithIgnCase(wordStart, "Black") ||
         ffStrStartsWithIgnCase(wordStart, "Condensed") ||
-        ffStrStartsWithIgnCase(wordStart, "Expanded")
-    ) {
-        if(alternativeBuffer == NULL)
-        {
-            alternativeBuffer = (FFstrbuf*) ffListAdd(&font->styles);
+        ffStrStartsWithIgnCase(wordStart, "Expanded")) {
+        if (alternativeBuffer == nullptr) {
+            alternativeBuffer = FF_LIST_ADD(FFstrbuf, font->styles);
             ffStrbufInit(alternativeBuffer);
         }
 
         strbufAppendNSExcludingC(alternativeBuffer, wordLength, wordStart, '-');
 
-        if(
+        if (
             ffStrStartsWithIgnCase(wordStart, "Ultra ") ||
             ffStrStartsWithIgnCase(wordStart, "Extra ") ||
             ffStrStartsWithIgnCase(wordStart, "Semi ") ||
-            ffStrStartsWithIgnCase(wordStart, "Demi ")
-        ) {
+            ffStrStartsWithIgnCase(wordStart, "Demi ")) {
             fontPangoParseWord(data, font, alternativeBuffer);
         }
 
         return;
     }
 
-    if(alternativeBuffer != NULL)
-    {
+    if (alternativeBuffer != nullptr) {
         strbufAppendNSExcludingC(alternativeBuffer, wordLength, wordStart, '-');
         return;
     }
 
-    if(font->name.length > 0)
+    if (font->name.length > 0) {
         ffStrbufAppendC(&font->name, ' ');
+    }
     ffStrbufAppendNS(&font->name, wordLength, wordStart);
 }
 
-void ffFontInitPango(FFfont* font, const char* data)
-{
+void ffFontInitPango(FFfont* font, const char* data) {
     ffFontInit(font);
 
-    while(*data != '\0' && *data != '`' && *data != '\\')
-        fontPangoParseWord(&data, font, NULL);
+    while (*data != '\0' && *data != '`' && *data != '\\') {
+        fontPangoParseWord(&data, font, nullptr);
+    }
 
     fontInitPretty(font);
 }
 
-void ffFontInitValues(FFfont* font, const char* name, const char* size)
-{
+void ffFontInitValues(FFfont* font, const char* name, const char* size) {
     ffFontInit(font);
 
     ffStrbufAppendS(&font->name, name);
@@ -196,8 +200,7 @@ void ffFontInitValues(FFfont* font, const char* name, const char* size)
     fontInitPretty(font);
 }
 
-void ffFontInitXlfd(FFfont* font, const char* xlfd)
-{
+void ffFontInitXlfd(FFfont* font, const char* xlfd) {
     assert(xlfd && *xlfd);
 
     // https://en.wikipedia.org/wiki/X_logical_font_description
@@ -205,80 +208,78 @@ void ffFontInitXlfd(FFfont* font, const char* xlfd)
 
     // XLFD: -foundry-family-weight-slant-setwidth-addstyle-pixelsize-pointsize-xres-yres-spacing-averagewidth-charsetregistry-charsetencoding
     // It often starts with '-', which would create an empty first field. Skip it to align indexes.
-    if(*xlfd == '-')
+    if (*xlfd == '-') {
         xlfd++;
+    }
 
     const char* pstart = xlfd;
 
-    for(int field = 0; field < 14; field++)
-    {
+    for (int field = 0; field < 14; field++) {
         const char* pend = strchr(pstart, '-');
-        uint32_t length = pend ? (uint32_t)(pend - pstart) : (uint32_t) strlen(pstart);
+        uint32_t length = pend ? (uint32_t) (pend - pstart) : (uint32_t) strlen(pstart);
 
-        if(length > 0)
-        {
-            if(field == 1) // family
+        if (length > 0) {
+            if (field == 1) // family
             {
                 ffStrbufAppendNS(&font->name, length, pstart);
-            }
-            else if(field == 7) // pointsize (decipoints, preferred)
+            } else if (field == 7) // pointsize (decipoints, preferred)
             {
                 // parse positive integer from substring
                 long deciPt = 0;
                 bool ok = true;
-                for(uint32_t i = 0; i < length; i++)
-                {
+                for (uint32_t i = 0; i < length; i++) {
                     char c = pstart[i];
-                    if(c < '0' || c > '9') { ok = false; break; }
+                    if (c < '0' || c > '9') {
+                        ok = false;
+                        break;
+                    }
                     deciPt = deciPt * 10 + (c - '0');
                 }
 
-                if(ok && deciPt > 0)
-                {
+                if (ok && deciPt > 0) {
                     ffStrbufClear(&font->size);
 
                     char tmp[32];
-                    if(deciPt % 10 == 0)
+                    if (deciPt % 10 == 0) {
                         snprintf(tmp, sizeof(tmp), "%ldpt", deciPt / 10);
-                    else
+                    } else {
                         snprintf(tmp, sizeof(tmp), "%ld.%ldpt", deciPt / 10, deciPt % 10);
+                    }
 
                     ffStrbufAppendS(&font->size, tmp);
                 }
-            }
-            else if(field == 6) // pixelsize (fallback if pointsize missing/invalid)
+            } else if (field == 6) // pixelsize (fallback if pointsize missing/invalid)
             {
-                if(font->size.length == 0)
-                {
+                if (font->size.length == 0) {
                     long px = 0;
                     bool ok = true;
-                    for(uint32_t i = 0; i < length; i++)
-                    {
+                    for (uint32_t i = 0; i < length; i++) {
                         char c = pstart[i];
-                        if(c < '0' || c > '9') { ok = false; break; }
+                        if (c < '0' || c > '9') {
+                            ok = false;
+                            break;
+                        }
                         px = px * 10 + (c - '0');
                     }
 
-                    if(ok && px > 0)
-                    {
+                    if (ok && px > 0) {
                         ffStrbufAppendNS(&font->size, length, pstart);
                         ffStrbufAppendS(&font->size, "px");
                     }
                 }
-            }
-            else if(field >= 2 && field <= 5) // weight/slant/setwidth/addstyle
+            } else if (field >= 2 && field <= 5) // weight/slant/setwidth/addstyle
             {
                 // ignore "normal" (case-insensitive)
-                if(!(length == 6 && ffStrStartsWithIgnCase(pstart, "normal")))
-                {
-                    FFstrbuf* style = (FFstrbuf*) ffListAdd(&font->styles);
+                if (!(length == 6 && ffStrStartsWithIgnCase(pstart, "normal"))) {
+                    FFstrbuf* style = FF_LIST_ADD(FFstrbuf, font->styles);
                     ffStrbufInitNS(style, length, pstart);
                 }
             }
         }
 
-        if(!pend)
+        if (!pend) {
             break;
+        }
 
         pstart = pend + 1;
     }
@@ -286,8 +287,7 @@ void ffFontInitXlfd(FFfont* font, const char* xlfd)
     fontInitPretty(font);
 }
 
-void ffFontInitXft(FFfont* font, const char* xft)
-{
+void ffFontInitXft(FFfont* font, const char* xft) {
     assert(xft);
 
     // https://en.wikipedia.org/wiki/Xft
@@ -302,84 +302,81 @@ void ffFontInitXft(FFfont* font, const char* xft)
     // 1) Parse "head" part before first ':' => usually "family[-size]" (may include commas)
     const char* p = xft;
 
-    while(*p == ' ' || *p == '\t')
+    while (*p == ' ' || *p == '\t') {
         ++p;
+    }
 
     const char* headStart = p;
-    while(*p != '\0' && *p != ':')
+    while (*p != '\0' && *p != ':') {
         ++p;
+    }
     const char* headEnd = p;
 
     // trim tail spaces
-    while(headEnd > headStart && (headEnd[-1] == ' ' || headEnd[-1] == '\t'))
+    while (headEnd > headStart && (headEnd[-1] == ' ' || headEnd[-1] == '\t')) {
         --headEnd;
+    }
 
     // If multiple families are listed, take the first one (up to comma)
-    for(const char* q = headStart; q < headEnd; ++q)
-    {
-        if(*q == ',')
-        {
+    for (const char* q = headStart; q < headEnd; ++q) {
+        if (*q == ',') {
             headEnd = q;
-            while(headEnd > headStart && (headEnd[-1] == ' ' || headEnd[-1] == '\t'))
+            while (headEnd > headStart && (headEnd[-1] == ' ' || headEnd[-1] == '\t')) {
                 --headEnd;
+            }
             break;
         }
     }
 
     // Try parse trailing "-<number>" as size, otherwise entire head is name
-    const char* dashPos = NULL;
-    const char* sizeStart = NULL;
+    const char* dashPos = nullptr;
+    const char* sizeStart = nullptr;
 
-    for(const char* q = headEnd; q > headStart; )
-    {
+    for (const char* q = headEnd; q > headStart;) {
         --q;
-        if(*q == '-' && (q + 1) < headEnd && ffCharIsDigit(q[1]))
-        {
+        if (*q == '-' && (q + 1) < headEnd && ffCharIsDigit(q[1])) {
             dashPos = q;
             sizeStart = q + 1;
             break;
         }
     }
 
-    if(dashPos)
-    {
+    if (dashPos) {
         bool ok = true;
         bool seenDigit = false;
-        for(const char* q = sizeStart; q < headEnd; ++q)
-        {
-            if(ffCharIsDigit(*q))
+        for (const char* q = sizeStart; q < headEnd; ++q) {
+            if (ffCharIsDigit(*q)) {
                 seenDigit = true;
-            else if(*q == '.')
+            } else if (*q == '.') {
                 continue;
-            else
-            {
+            } else {
                 ok = false;
                 break;
             }
         }
 
-        if(ok && seenDigit)
-        {
+        if (ok && seenDigit) {
             const char* nameEnd = dashPos;
-            while(nameEnd > headStart && (nameEnd[-1] == ' ' || nameEnd[-1] == '\t'))
+            while (nameEnd > headStart && (nameEnd[-1] == ' ' || nameEnd[-1] == '\t')) {
                 --nameEnd;
+            }
 
-            if(nameEnd > headStart)
+            if (nameEnd > headStart) {
                 ffStrbufAppendNS(&font->name, (uint32_t) (nameEnd - headStart), headStart);
+            }
 
-            if(headEnd > sizeStart)
+            if (headEnd > sizeStart) {
                 ffStrbufAppendNS(&font->size, (uint32_t) (headEnd - sizeStart), sizeStart);
-        }
-        else
-        {
-            if(headEnd > headStart)
+            }
+        } else {
+            if (headEnd > headStart) {
                 ffStrbufAppendNS(&font->name, (uint32_t) (headEnd - headStart), headStart);
+            }
         }
-    }
-    else
-    {
-        if(headEnd > headStart)
+    } else {
+        if (headEnd > headStart) {
             ffStrbufAppendNS(&font->name, (uint32_t) (headEnd - headStart), headStart);
+        }
     }
 
     ffStrbufTrim(&font->name, ' ');
@@ -387,28 +384,27 @@ void ffFontInitXft(FFfont* font, const char* xft)
 
     // 2) Parse key=value fields after ':' (Fontconfig-like). Fields separated by ':'.
     // Common keys: size, pixelsize, pointsize, style, weight, slant, width
-    while(*p == ':')
-    {
+    while (*p == ':') {
         ++p;
 
         // key
         const char* keyStart = p;
-        while(*p != '\0' && *p != '=' && *p != ':')
+        while (*p != '\0' && *p != '=' && *p != ':') {
             ++p;
+        }
         const char* keyEnd = p;
 
-        if(*p != '=')
+        if (*p != '=') {
             continue; // skip tokens without '='
+        }
 
         ++p; // skip '='
 
         // value (until next ':', allow backslash-escaping)
         FF_STRBUF_AUTO_DESTROY value = ffStrbufCreate();
 
-        while(*p != '\0' && *p != ':')
-        {
-            if(*p == '\\' && p[1] != '\0')
-            {
+        while (*p != '\0' && *p != ':') {
+            if (*p == '\\' && p[1] != '\0') {
                 ++p;
                 ffStrbufAppendC(&value, *p);
                 ++p;
@@ -426,49 +422,46 @@ void ffFontInitXft(FFfont* font, const char* xft)
 
         // helper: set numeric size if not set yet
         const bool sizeEmpty = (font->size.length == 0);
-        if(value.length > 0)
-        {
-            if(
+        if (value.length > 0) {
+            if (
                 (keyLen == 4 && ffStrStartsWithIgnCase(keyStart, "size")) ||
-                (keyLen == 9 && ffStrStartsWithIgnCase(keyStart, "pixelsize"))
-            )
-            {
-                if(sizeEmpty && ffCharIsDigit(value.chars[0]))
-                {
+                (keyLen == 9 && (ffStrStartsWithIgnCase(keyStart, "pixelsize") || ffStrStartsWithIgnCase(keyStart, "pointsize")))) {
+                if (sizeEmpty && ffCharIsDigit(value.chars[0])) {
                     ffStrbufAppend(&font->size, &value);
-                    ffStrbufAppendS(&font->size, keyLen == 4 ? "pt" : "px");
+                    ffStrbufAppendS(&font->size,
+                        (keyLen == 9 && ffStrStartsWithIgnCase(keyStart, "pixelsize")) ? "px" : "pt");
                 }
-            }
-            else if(keyLen == 5 && ffStrStartsWithIgnCase(keyStart, "style"))
-            {
+            } else if (keyLen == 5 && ffStrStartsWithIgnCase(keyStart, "style")) {
                 // style may contain multiple words: "Bold Italic"
                 const char* s = value.chars;
-                while(*s != '\0')
-                {
-                    while(*s == ' ' || *s == '\t' || *s == ',')
+                while (*s != '\0') {
+                    while (*s == ' ' || *s == '\t' || *s == ',') {
                         ++s;
+                    }
 
                     const char* w = s;
-                    while(*s != '\0' && *s != ' ' && *s != '\t' && *s != ',')
+                    while (*s != '\0' && *s != ' ' && *s != '\t' && *s != ',') {
                         ++s;
+                    }
 
-                    if(s > w)
-                    {
+                    if (s > w) {
                         FFstrbuf* style = FF_LIST_ADD(FFstrbuf, font->styles);
                         ffStrbufInitNS(style, (uint32_t) (s - w), w);
                     }
                 }
-            }
-            else if(
+            } else if (
                 (keyLen == 6 && ffStrStartsWithIgnCase(keyStart, "weight")) ||
                 (keyLen == 5 && ffStrStartsWithIgnCase(keyStart, "slant")) ||
-                (keyLen == 5 && ffStrStartsWithIgnCase(keyStart, "width"))
-            ) {
+                (keyLen == 5 && ffStrStartsWithIgnCase(keyStart, "width"))) {
                 // normalize: remove '-' to align with other parsers ("Semi-Bold" -> "SemiBold")
                 FFstrbuf* style = FF_LIST_ADD(FFstrbuf, font->styles);
                 ffStrbufInit(style);
                 strbufAppendNSExcludingC(style, value.length, value.chars, '-');
                 ffStrbufTrim(style, ' ');
+                if (style->length == 0) {
+                    ffStrbufDestroy(style);
+                    --font->styles.length;
+                }
             }
         }
     }
@@ -476,14 +469,16 @@ void ffFontInitXft(FFfont* font, const char* xft)
     fontInitPretty(font);
 }
 
-void ffFontInitMoveValues(FFfont* font, FFstrbuf* name, FFstrbuf* size, FFstrbuf* style)
-{
+void ffFontInitMoveValues(FFfont* font, FFstrbuf* name, FFstrbuf* size, FFstrbuf* style) {
     ffFontInit(font);
 
-    if (name) ffStrbufInitMove(&font->name, name);
-    if (size) ffStrbufInitMove(&font->size, size);
-    if (style)
-    {
+    if (name) {
+        ffStrbufInitMove(&font->name, name);
+    }
+    if (size) {
+        ffStrbufInitMove(&font->size, size);
+    }
+    if (style) {
         FFstrbuf* styleBuf = FF_LIST_ADD(FFstrbuf, font->styles);
         ffStrbufInitMove(styleBuf, style);
     }
@@ -491,30 +486,28 @@ void ffFontInitMoveValues(FFfont* font, FFstrbuf* name, FFstrbuf* size, FFstrbuf
     fontInitPretty(font);
 }
 
-void ffFontInitWithSpace(FFfont* font, const char* rawName)
-{
+void ffFontInitWithSpace(FFfont* font, const char* rawName) {
     const char* pspace = strrchr(rawName, ' ');
-    if(pspace == NULL)
-    {
+    if (pspace == nullptr) {
         ffFontInitCopy(font, rawName);
         return;
     }
 
     ffFontInit(font);
 
-    ffStrbufAppendNS(&font->name, (uint32_t)(pspace - rawName), rawName);
+    ffStrbufAppendNS(&font->name, (uint32_t) (pspace - rawName), rawName);
     ffStrbufAppendS(&font->size, pspace + 1);
 
     fontInitPretty(font);
 }
 
-void ffFontDestroy(FFfont* font)
-{
+void ffFontDestroy(FFfont* font) {
     ffStrbufDestroy(&font->pretty);
     ffStrbufDestroy(&font->name);
     ffStrbufDestroy(&font->size);
 
-    FF_LIST_FOR_EACH(FFstrbuf, str, font->styles)
+    FF_LIST_FOR_EACH (FFstrbuf, str, font->styles) {
         ffStrbufDestroy(str);
+    }
     ffListDestroy(&font->styles);
 }

src/common/impl/format.c

@@ -2,58 +2,63 @@
 #include "common/format.h"
 #include "common/parsing.h"
 #include "common/textModifier.h"
-#include "common/stringUtils.h"
+#include "common/strutil.h"
+#include "common/library.h"
 
 #include <inttypes.h>
 
-void ffFormatAppendFormatArg(FFstrbuf* buffer, const FFformatarg* formatarg)
-{
-    switch(formatarg->type)
-    {
-        case FF_FORMAT_ARG_TYPE_INT:
-            ffStrbufAppendSInt(buffer, *(int32_t*)formatarg->value);
+void ffFormatAppendFormatArg(FFstrbuf* buffer, const FFformatarg* formatarg) {
+    switch (formatarg->type) {
+        case FF_ARG_TYPE_INT:
+            ffStrbufAppendSInt(buffer, *(int32_t*) formatarg->value);
             break;
-        case FF_FORMAT_ARG_TYPE_UINT:
-            ffStrbufAppendUInt(buffer, *(uint32_t*)formatarg->value);
+        case FF_ARG_TYPE_UINT:
+            ffStrbufAppendUInt(buffer, *(uint32_t*) formatarg->value);
             break;
-        case FF_FORMAT_ARG_TYPE_UINT64:
-            ffStrbufAppendUInt(buffer, *(uint64_t*)formatarg->value);
+        case FF_ARG_TYPE_UINT64:
+            ffStrbufAppendUInt(buffer, *(uint64_t*) formatarg->value);
             break;
-        case FF_FORMAT_ARG_TYPE_UINT16:
-            ffStrbufAppendUInt(buffer, *(uint16_t*)formatarg->value);
+        case FF_ARG_TYPE_UINT16:
+            ffStrbufAppendUInt(buffer, *(uint16_t*) formatarg->value);
             break;
-        case FF_FORMAT_ARG_TYPE_UINT8:
-            ffStrbufAppendUInt(buffer, *(uint8_t*)formatarg->value);
+        case FF_ARG_TYPE_UINT8:
+            ffStrbufAppendUInt(buffer, *(uint8_t*) formatarg->value);
             break;
-        case FF_FORMAT_ARG_TYPE_STRING:
-            ffStrbufAppendS(buffer, (const char*)formatarg->value);
+        case FF_ARG_TYPE_STRING:
+            ffStrbufAppendS(buffer, (const char*) formatarg->value);
             break;
-        case FF_FORMAT_ARG_TYPE_STRBUF:
-            ffStrbufAppend(buffer, (const FFstrbuf*)formatarg->value);
+        case FF_ARG_TYPE_STRBUF:
+            ffStrbufAppend(buffer, (const FFstrbuf*) formatarg->value);
             break;
-        case FF_FORMAT_ARG_TYPE_FLOAT:
-            ffStrbufAppendDouble(buffer, *(float*)formatarg->value, instance.config.display.fractionNdigits, instance.config.display.fractionTrailingZeros != FF_FRACTION_TRAILING_ZEROS_TYPE_NEVER);
+        case FF_ARG_TYPE_FLOAT:
+            ffStrbufAppendDouble(buffer, *(float*) formatarg->value, instance.config.display.fractionNdigits, instance.config.display.fractionTrailingZeros != FF_FRACTION_TRAILING_ZEROS_TYPE_NEVER);
             break;
-        case FF_FORMAT_ARG_TYPE_DOUBLE:
-            ffStrbufAppendDouble(buffer, *(double*)formatarg->value, instance.config.display.fractionNdigits, instance.config.display.fractionTrailingZeros != FF_FRACTION_TRAILING_ZEROS_TYPE_NEVER);
+        case FF_ARG_TYPE_DOUBLE:
+            ffStrbufAppendDouble(buffer, *(double*) formatarg->value, instance.config.display.fractionNdigits, instance.config.display.fractionTrailingZeros != FF_FRACTION_TRAILING_ZEROS_TYPE_NEVER);
             break;
-        case FF_FORMAT_ARG_TYPE_BOOL:
-            ffStrbufAppendS(buffer, *(bool*)formatarg->value ? "true" : "false");
+        case FF_ARG_TYPE_BOOL:
+            ffStrbufAppendS(buffer, *(bool*) formatarg->value ? "true" : "false");
             break;
-        case FF_FORMAT_ARG_TYPE_LIST:
-        {
+        case FF_ARG_TYPE_LIST: {
             const FFlist* list = (const FFlist*) formatarg->value;
-            for(uint32_t i = 0; i < list->length; i++)
-            {
+            for (uint32_t i = 0; i < list->length; i++) {
                 ffStrbufAppend(buffer, FF_LIST_GET(FFstrbuf, *list, i));
-                if(i < list->length - 1)
+                if (i < list->length - 1) {
                     ffStrbufAppendS(buffer, ", ");
+                }
             }
             break;
         }
+        case FF_ARG_TYPE_BUFFER: {
+            // Placeholder for binary data, just print the size for now
+            const FFArgBuffer* argBuffer = (const FFArgBuffer*) formatarg->value;
+            ffStrbufAppendF(buffer, "buffer(%u bytes)", argBuffer->length);
+            break;
+        }
         default:
-            if(formatarg->type != FF_FORMAT_ARG_TYPE_NULL)
+            if (formatarg->type != FF_ARG_TYPE_NULL) {
                 fprintf(stderr, "Error: format string \"%s\": argument is not implemented: %i\n", buffer->chars, formatarg->type);
+            }
             break;
     }
 }
@@ -66,62 +71,401 @@ void ffFormatAppendFormatArg(FFstrbuf* buffer, const FFformatarg* formatarg)
  * @param placeholderValue the string to parse
  * @return uint32_t the parsed value
  */
-static uint32_t getArgumentIndex(const char* placeholderValue, uint32_t numArgs, const FFformatarg* arguments)
-{
+static uint32_t getArgumentIndex(const char* placeholderValue, uint32_t numArgs, const FFformatarg* arguments) {
     char firstChar = placeholderValue[0];
-    if (firstChar == '\0')
+    if (firstChar == '\0') {
         return 0; // use arg counter
-
-    if (firstChar >= '0' && firstChar <= '9')
-    {
-        char* pEnd = NULL;
-        uint32_t result = (uint32_t) strtoul(placeholderValue, &pEnd, 10);
-        if (result > numArgs)
-            return UINT32_MAX;
-        if (*pEnd != '\0')
-            return UINT32_MAX;
-        return result;
     }
-    else if (ffCharIsEnglishAlphabet(firstChar))
-    {
-        for (uint32_t i = 0; i < numArgs; ++i)
-        {
+
+    if (firstChar >= '0' && firstChar <= '9') {
+        char* pEnd = nullptr;
+        uint32_t result = (uint32_t) strtoul(placeholderValue, &pEnd, 10);
+        if (result > numArgs) {
+            return UINT32_MAX;
+        }
+        if (*pEnd != '\0') {
+            return UINT32_MAX;
+        }
+        return result;
+    } else if (ffCharIsEnglishAlphabet(firstChar)) {
+        for (uint32_t i = 0; i < numArgs; ++i) {
             const FFformatarg* arg = &arguments[i];
-            if (arg->name && ffStrEqualsIgnCase(placeholderValue, arg->name))
+            if (arg->name && ffStrEqualsIgnCase(placeholderValue, arg->name)) {
                 return i + 1;
+            }
         }
     }
 
     return UINT32_MAX;
 }
 
-static inline void appendInvalidPlaceholder(FFstrbuf* buffer, const char* start, const FFstrbuf* placeholderValue, uint32_t index, uint32_t formatStringLength)
-{
+static inline void appendInvalidPlaceholder(FFstrbuf* buffer, const char* start, const FFstrbuf* placeholderValue, uint32_t index, uint32_t formatStringLength) {
     ffStrbufAppendS(buffer, start);
     ffStrbufAppend(buffer, placeholderValue);
 
-    if(index < formatStringLength)
+    if (index < formatStringLength) {
         ffStrbufAppendC(buffer, '}');
+    }
 }
 
-static inline bool formatArgSet(const FFformatarg* arg)
-{
-    return arg->value != NULL && (
-        (arg->type == FF_FORMAT_ARG_TYPE_DOUBLE && *(double*)arg->value > 0.0) ||
-        (arg->type == FF_FORMAT_ARG_TYPE_FLOAT && *(float*)arg->value > 0.0) ||
-        (arg->type == FF_FORMAT_ARG_TYPE_INT && *(int*)arg->value > 0) ||
-        (arg->type == FF_FORMAT_ARG_TYPE_STRBUF && ((FFstrbuf*)arg->value)->length > 0) ||
-        (arg->type == FF_FORMAT_ARG_TYPE_STRING && ffStrSet((char*)arg->value)) ||
-        (arg->type == FF_FORMAT_ARG_TYPE_UINT8 && *(uint8_t*)arg->value > 0) ||
-        (arg->type == FF_FORMAT_ARG_TYPE_UINT16 && *(uint16_t*)arg->value > 0) ||
-        (arg->type == FF_FORMAT_ARG_TYPE_UINT && *(uint32_t*)arg->value > 0) ||
-        (arg->type == FF_FORMAT_ARG_TYPE_BOOL && *(bool*)arg->value) ||
-        (arg->type == FF_FORMAT_ARG_TYPE_LIST && ((FFlist*)arg->value)->length > 0)
+static inline bool formatArgSet(const FFformatarg* arg) {
+    // clang-format off
+    return arg->value != nullptr && (
+        (arg->type == FF_ARG_TYPE_DOUBLE && *(double*) arg->value > 0.0) ||
+        (arg->type == FF_ARG_TYPE_FLOAT && *(float*) arg->value > 0.0) ||
+        (arg->type == FF_ARG_TYPE_INT && *(int32_t*) arg->value > 0) ||
+        (arg->type == FF_ARG_TYPE_STRBUF && ((FFstrbuf*) arg->value)->length > 0) ||
+        (arg->type == FF_ARG_TYPE_STRING && ffStrSet((char*) arg->value)) ||
+        (arg->type == FF_ARG_TYPE_UINT8 && *(uint8_t*) arg->value > 0) ||
+        (arg->type == FF_ARG_TYPE_UINT16 && *(uint16_t*) arg->value > 0) ||
+        (arg->type == FF_ARG_TYPE_UINT && *(uint32_t*) arg->value > 0) ||
+        (arg->type == FF_ARG_TYPE_UINT64 && *(uint64_t*) arg->value > 0) ||
+        (arg->type == FF_ARG_TYPE_BOOL && *(bool*) arg->value) ||
+        (arg->type == FF_ARG_TYPE_LIST && ((FFlist*) arg->value)->length > 0)
     );
+    // clang-format on
 }
 
-void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t numArgs, const FFformatarg* arguments)
-{
+[[maybe_unused]] static inline void normalizeArgName(FFstrbuf* dst, const char* src) {
+    ffStrbufClear(dst);
+    bool flag = false;
+    for (const char* p = src; *p; ++p) {
+        if (*p == '-') {
+            flag = true;
+        } else if (flag) {
+            ffStrbufAppendC(dst, (char) toupper((unsigned char) *p));
+            flag = false;
+        } else {
+            ffStrbufAppendC(dst, *p);
+        }
+    }
+}
+
+#if FF_HAVE_LUA
+    #include "common/lua.h"
+
+static void appendLuaError(FFstrbuf* buffer, const char* prefix, lua_State* L) {
+    const char* err = lua_tolstring(L, -1, nullptr);
+    if (err) {
+        const char* tmp = strchr(err, ':');
+        if (tmp) {
+            err = tmp + 1;
+            while (*err == ' ') {
+                ++err;
+            }
+        }
+    }
+    ffStrbufAppendF(buffer, "%s: %s", prefix, err ? err : "unknown");
+}
+
+static bool parseLuaString(FFstrbuf* buffer, const char* script, uint32_t scriptLen, uint32_t numArgs, const FFformatarg* arguments) {
+    const char* err = ffLuaLoadState();
+    if (err) {
+        ffStrbufAppendF(buffer, "Lua init error: %s", err);
+        return false;
+    }
+
+    FF_STRBUF_AUTO_DESTROY argNameBuf = ffStrbufCreate();
+    bool ret = false;
+
+    lua_State* L = luaData.L;
+    // Clear stack and load chunk
+    lua_settop(L, 0);
+    if (luaL_loadbuffer(L, script, scriptLen, "") != LUA_OK) {
+        appendLuaError(buffer, "Lua load error", L);
+    } else {
+        // Build args table for name lookup only.
+        lua_createtable(L, 0, 0);
+
+        for (uint32_t i = 0; i < numArgs; ++i) {
+            const FFformatarg* arg = &arguments[i];
+            switch (arg->type) {
+                case FF_ARG_TYPE_INT:
+                    lua_pushinteger(L, (lua_Integer) * (int32_t*) arg->value);
+                    break;
+                case FF_ARG_TYPE_UINT:
+                    lua_pushinteger(L, (lua_Integer) * (uint32_t*) arg->value);
+                    break;
+                case FF_ARG_TYPE_UINT64:
+                    lua_pushinteger(L, (lua_Integer) * (uint64_t*) arg->value);
+                    break;
+                case FF_ARG_TYPE_UINT16:
+                    lua_pushinteger(L, (lua_Integer) * (uint16_t*) arg->value);
+                    break;
+                case FF_ARG_TYPE_UINT8:
+                    lua_pushinteger(L, (lua_Integer) * (uint8_t*) arg->value);
+                    break;
+                case FF_ARG_TYPE_FLOAT:
+                    lua_pushnumber(L, (lua_Number) * (float*) arg->value);
+                    break;
+                case FF_ARG_TYPE_DOUBLE:
+                    lua_pushnumber(L, (lua_Number) * (double*) arg->value);
+                    break;
+                case FF_ARG_TYPE_BOOL:
+                    lua_pushboolean(L, *(bool*) arg->value);
+                    break;
+                case FF_ARG_TYPE_STRING:
+                    lua_pushlstring(L, (const char*) arg->value, strlen((const char*) arg->value));
+                    break;
+                case FF_ARG_TYPE_STRBUF: {
+                    const FFstrbuf* sb = (const FFstrbuf*) arg->value;
+                    lua_pushlstring(L, sb->chars, sb->length);
+                    break;
+                }
+                case FF_ARG_TYPE_LIST: {
+                    const FFlist* list = (const FFlist*) arg->value;
+                    lua_createtable(L, 0, 0);
+                    for (uint32_t li = 0; li < list->length; ++li) {
+                        const FFstrbuf* item = FF_LIST_GET(FFstrbuf, *list, li);
+                        lua_pushlstring(L, item->chars, item->length);
+                        lua_seti(L, -2, (lua_Integer) (li + 1));
+                    }
+                    break;
+                }
+                default:
+                    lua_pushnil(L);
+                    break;
+            }
+            if (arg->name && arg->name[0]) {
+                normalizeArgName(&argNameBuf, arg->name);
+            } else {
+                ffStrbufSetF(&argNameBuf, "arg%" PRIu32, i + 1);
+            }
+            lua_setfield(L, -2, argNameBuf.chars);
+        }
+
+        if (lua_pcall(L, 1, LUA_MULTRET, 0) != LUA_OK) {
+            appendLuaError(buffer, "Lua runtime error", L);
+        } else {
+            int nresults = lua_gettop(L);
+            if (nresults == 0) {
+                ffStrbufAppendS(buffer, "Lua result error: no result");
+            } else {
+                // Convert first result to string
+                const char* res = lua_tolstring(L, 1, nullptr);
+                if (res) {
+                    ffStrbufAppendS(buffer, res);
+                } else {
+                    luaL_tolstring(L, 1, nullptr);
+                    const char* sval = lua_tolstring(L, -1, nullptr);
+                    if (sval) {
+                        ffStrbufAppendS(buffer, sval);
+                    }
+                }
+                ret = true;
+            }
+        }
+    }
+    lua_settop(L, 0);
+    return ret;
+}
+#endif
+
+#if FF_HAVE_QUICKJS
+    #include <quickjs.h>
+
+struct FFQuickJSData {
+    FF_LIBRARY_SYMBOL(JS_NewRuntime)
+    FF_LIBRARY_SYMBOL(JS_NewContext)
+    FF_LIBRARY_SYMBOL(JS_FreeRuntime)
+    FF_LIBRARY_SYMBOL(JS_EvalThis)
+    FF_LIBRARY_SYMBOL(JS_GetException)
+    FF_LIBRARY_SYMBOL(JS_ToCStringLen2)
+    FF_LIBRARY_SYMBOL(JS_FreeCString)
+    FF_LIBRARY_SYMBOL(JS_NewStringLen)
+    FF_LIBRARY_SYMBOL(JS_NewArray)
+    FF_LIBRARY_SYMBOL(JS_NewBigUint64)
+    FF_LIBRARY_SYMBOL(JS_SetPropertyUint32)
+    FF_LIBRARY_SYMBOL(JS_NewObject)
+    FF_LIBRARY_SYMBOL(JS_SetPropertyStr)
+    FF_LIBRARY_SYMBOL(JS_FreeValue)
+
+    JSRuntime* rt;
+    JSContext* ctx;
+    bool inited;
+} qjsData;
+
+static const char* loadQuickJSState(void) {
+    if (qjsData.inited) {
+        if (qjsData.ctx == nullptr) {
+            return "QuickJS is not available";
+        }
+        return nullptr;
+    }
+
+    qjsData.inited = true;
+    #ifdef _WIN32
+    FF_LIBRARY_LOAD_MESSAGE(libqjs, "libqjs-0" FF_LIBRARY_EXTENSION, 0)
+    #else
+    FF_LIBRARY_LOAD_MESSAGE(libqjs, "libqjs" FF_LIBRARY_EXTENSION, 0)
+    #endif
+
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libqjs, qjsData, JS_NewRuntime)
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libqjs, qjsData, JS_NewContext)
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libqjs, qjsData, JS_FreeRuntime)
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libqjs, qjsData, JS_EvalThis)
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libqjs, qjsData, JS_GetException)
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libqjs, qjsData, JS_ToCStringLen2)
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libqjs, qjsData, JS_FreeCString)
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libqjs, qjsData, JS_NewStringLen)
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libqjs, qjsData, JS_NewArray)
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libqjs, qjsData, JS_SetPropertyUint32)
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libqjs, qjsData, JS_NewObject)
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libqjs, qjsData, JS_SetPropertyStr)
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libqjs, qjsData, JS_FreeValue)
+
+    qjsData.rt = qjsData.ffJS_NewRuntime();
+    if (qjsData.rt == nullptr) {
+        return "JS_NewRuntime() failed";
+    }
+
+    qjsData.ctx = qjsData.ffJS_NewContext(qjsData.rt);
+    if (qjsData.ctx == nullptr) {
+        qjsData.ffJS_FreeRuntime(qjsData.rt);
+        qjsData.rt = nullptr;
+        return "JS_NewContext() failed";
+    }
+
+    libqjs = nullptr; // don't close quickjs
+
+    return nullptr;
+}
+
+static bool parseQuickJSString(FFstrbuf* buffer, const char* script, uint32_t scriptLen, uint32_t numArgs, const FFformatarg* arguments) {
+    const char* err = loadQuickJSState();
+    if (err) {
+        ffStrbufAppendF(buffer, "Qjs init error: %s", err);
+        return false;
+    }
+    JSContext* ctx = qjsData.ctx;
+    JSValue argsObj = qjsData.ffJS_NewObject(ctx);
+    FF_STRBUF_AUTO_DESTROY argNameBuf = ffStrbufCreate();
+
+    for (uint32_t i = 0; i < numArgs; ++i) {
+        const FFformatarg* arg = &arguments[i];
+
+        JSValue value;
+        switch (arg->type) {
+            case FF_ARG_TYPE_INT:
+                value = JS_NewInt32(ctx, *(int32_t*) arg->value);
+                break;
+            case FF_ARG_TYPE_UINT:
+                value = JS_NewUint32(ctx, *(uint32_t*) arg->value);
+                break;
+            case FF_ARG_TYPE_UINT64: {
+                uint64_t val = *(uint64_t*) arg->value;
+                if (val <= INT32_MAX) {
+                    value = JS_NewInt32(ctx, (int32_t) val);
+                } else {
+                    value = JS_NewFloat64(ctx, (double) val);
+                }
+                break;
+            }
+            case FF_ARG_TYPE_UINT16:
+                value = JS_NewUint32(ctx, *(uint16_t*) arg->value);
+                break;
+            case FF_ARG_TYPE_UINT8:
+                value = JS_NewUint32(ctx, *(uint8_t*) arg->value);
+                break;
+            case FF_ARG_TYPE_FLOAT:
+                value = JS_NewFloat64(ctx, *(float*) arg->value);
+                break;
+            case FF_ARG_TYPE_DOUBLE:
+                value = JS_NewFloat64(ctx, *(double*) arg->value);
+                break;
+            case FF_ARG_TYPE_BOOL:
+                value = JS_NewBool(ctx, *(bool*) arg->value);
+                break;
+            case FF_ARG_TYPE_STRING:
+                value = qjsData.ffJS_NewStringLen(ctx, (const char*) arg->value, strlen((const char*) arg->value));
+                break;
+            case FF_ARG_TYPE_STRBUF: {
+                const FFstrbuf* sb = (const FFstrbuf*) arg->value;
+                value = qjsData.ffJS_NewStringLen(ctx, sb->chars, sb->length);
+                break;
+            }
+            case FF_ARG_TYPE_LIST: {
+                const FFlist* list = (const FFlist*) arg->value;
+                JSValue arr = qjsData.ffJS_NewArray(ctx);
+                for (uint32_t li = 0; li < list->length; ++li) {
+                    const FFstrbuf* item = FF_LIST_GET(FFstrbuf, *list, li);
+                    JSValue itemValue = qjsData.ffJS_NewStringLen(ctx, item->chars, item->length);
+                    qjsData.ffJS_SetPropertyUint32(ctx, arr, li, itemValue);
+                }
+
+                value = arr;
+                break;
+            }
+            default:
+                value = JS_UNDEFINED;
+                break;
+        }
+
+        if (arg->name && arg->name[0]) {
+            normalizeArgName(&argNameBuf, arg->name);
+        } else {
+            ffStrbufSetF(&argNameBuf, "arg%" PRIu32, i + 1);
+        }
+        qjsData.ffJS_SetPropertyStr(ctx, argsObj, argNameBuf.chars, value);
+    }
+    JSValue result = qjsData.ffJS_EvalThis(ctx, argsObj, script, scriptLen, "", JS_EVAL_TYPE_GLOBAL | JS_EVAL_FLAG_STRICT);
+
+    qjsData.ffJS_FreeValue(ctx, argsObj);
+
+    bool ret = false;
+    if (JS_IsException(result)) {
+        JSValue exc = qjsData.ffJS_GetException(ctx);
+        const char* message = qjsData.ffJS_ToCStringLen2(ctx, nullptr, exc, false);
+        qjsData.ffJS_FreeValue(ctx, exc);
+        ffStrbufAppendF(buffer, "Qjs runtime error: %s", message ?: "unknown");
+        if (message) {
+            qjsData.ffJS_FreeCString(ctx, message);
+        }
+    } else if (JS_IsUndefined(result)) {
+        ffStrbufAppendS(buffer, "Qjs result error: undefined result");
+    } else {
+        size_t len;
+        const char* res = qjsData.ffJS_ToCStringLen2(ctx, &len, result, false);
+        if (res) {
+            ffStrbufAppendNS(buffer, (uint32_t) len, res);
+            qjsData.ffJS_FreeCString(ctx, res);
+        }
+        ret = true;
+    }
+
+    qjsData.ffJS_FreeValue(ctx, result);
+    return ret;
+}
+#endif
+
+static bool skipAnsiEscape(FFstrbuf* in, FFstrbuf* out, FFstrbuf* trailingEscape) {
+    if (__builtin_expect(in->chars[0] == '\e' && in->chars[1] == '[', false)) {
+        // skip ANSI escape codes at the start of the string for truncation
+        const char* p = in->chars + 2;
+        while (*p && (ffCharIsDigit(*p) || *p == ';')) {
+            ++p;
+        }
+        if (*p && isascii(*p)) {
+            ++p;
+        }
+        uint32_t prefixLen = (uint32_t) (p - in->chars);
+        ffStrbufAppendNS(out, prefixLen, in->chars);
+        ffStrbufSubstrAfter(in, prefixLen - 1);
+
+        if (trailingEscape) {
+            // likely have a `CSI m` reset at the end of the string
+            uint32_t iLastEscape = ffStrbufLastIndexC(in, '\e');
+            if (iLastEscape != in->length) {
+                ffStrbufSetNS(trailingEscape, in->length - iLastEscape, in->chars + iLastEscape);
+                ffStrbufSubstrBefore(in, iLastEscape);
+            }
+        }
+        return true;
+    }
+    return false;
+}
+
+static bool parseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t numArgs, const FFformatarg* arguments) {
     uint32_t argCounter = 0;
 
     uint32_t numOpenIfs = 0;
@@ -129,11 +473,9 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
 
     FF_STRBUF_AUTO_DESTROY placeholderValue = ffStrbufCreate();
 
-    for(uint32_t i = 0; i < formatstr->length; ++i)
-    {
+    for (uint32_t i = 0; i < formatstr->length; ++i) {
         // if we don't have a placeholder start just copy the chars over to output buffer
-        if(formatstr->chars[i] != '{')
-        {
+        if (formatstr->chars[i] != '{') {
             ffStrbufAppendC(buffer, formatstr->chars[i]);
             continue;
         }
@@ -141,9 +483,14 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
         // jump to next char, the start of the placeholder value
         ++i;
 
+        // unmatched trailing '{'
+        if (i >= formatstr->length) {
+            ffStrbufAppendC(buffer, '{');
+            break;
+        }
+
         // double {{ elvaluates to a single { and doesn't count as start
-        if(formatstr->chars[i] == '{')
-        {
+        if (formatstr->chars[i] == '{') {
             ffStrbufAppendC(buffer, '{');
             continue;
         }
@@ -158,61 +505,58 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
 
         char firstChar = placeholderValue.chars[0];
 
-        if (placeholderValue.length == 1)
-        {
+        if (placeholderValue.length == 1) {
             // test if for stop, if so break the loop
-            if (firstChar == '-')
+            if (firstChar == '-') {
                 break;
+            }
 
             // test for end of an if, if so do nothing
-            if (firstChar == '?')
-            {
-                if(numOpenIfs == 0)
+            if (firstChar == '?') {
+                if (numOpenIfs == 0) {
                     appendInvalidPlaceholder(buffer, "{", &placeholderValue, i, formatstr->length);
-                else
+                } else {
                     --numOpenIfs;
+                }
 
                 continue;
             }
 
             // test for end of a not if, if so do nothing
-            if (firstChar == '/')
-            {
-                if(numOpenNotIfs == 0)
+            if (firstChar == '/') {
+                if (numOpenNotIfs == 0) {
                     appendInvalidPlaceholder(buffer, "{", &placeholderValue, i, formatstr->length);
-                else
+                } else {
                     --numOpenNotIfs;
+                }
 
                 continue;
             }
 
             // test for end of a color, if so do nothing
-            if (firstChar == '#')
-            {
-                if (!instance.config.display.pipe)
+            if (firstChar == '#') {
+                if (!instance.config.display.pipe) {
                     ffStrbufAppendS(buffer, FASTFETCH_TEXT_MODIFIER_RESET);
+                }
 
                 continue;
             }
         }
 
         // test for if, if so evaluate it
-        if (firstChar == '?')
-        {
+        if (firstChar == '?') {
             ffStrbufSubstrAfter(&placeholderValue, 0);
 
             uint32_t index = getArgumentIndex(placeholderValue.chars, numArgs, arguments);
 
             // testing for an invalid index
-            if (index > numArgs || index < 1)
-            {
+            if (index > numArgs || index < 1) {
                 appendInvalidPlaceholder(buffer, "{?", &placeholderValue, i, formatstr->length);
                 continue;
             }
 
             // continue normally if an format arg is set and the value is > 0
-            if (formatArgSet(&arguments[index - 1]))
-            {
+            if (formatArgSet(&arguments[index - 1])) {
                 ++numOpenIfs;
                 continue;
             }
@@ -223,22 +567,19 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
         }
 
         // test for not if, if so evaluate it
-        if (firstChar == '/')
-        {
+        if (firstChar == '/') {
             ffStrbufSubstrAfter(&placeholderValue, 0);
 
             uint32_t index = getArgumentIndex(placeholderValue.chars, numArgs, arguments);
 
             // testing for an invalid index
-            if (index > numArgs || index < 1)
-            {
+            if (index > numArgs || index < 1) {
                 appendInvalidPlaceholder(buffer, "{/", &placeholderValue, i, formatstr->length);
                 continue;
             }
 
-            //continue normally if an format arg is not set or the value is 0
-            if (!formatArgSet(&arguments[index - 1]))
-            {
+            // continue normally if an format arg is not set or the value is 0
+            if (!formatArgSet(&arguments[index - 1])) {
                 ++numOpenNotIfs;
                 continue;
             }
@@ -248,11 +589,9 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
             continue;
         }
 
-        //test for color, if so evaluate it
-        if (firstChar == '#')
-        {
-            if (!instance.config.display.pipe)
-            {
+        // test for color, if so evaluate it
+        if (firstChar == '#') {
+            if (!instance.config.display.pipe) {
                 ffStrbufAppendS(buffer, "\e[");
                 ffOptionParseColorNoClear(placeholderValue.chars + 1, buffer);
                 ffStrbufAppendC(buffer, 'm');
@@ -260,29 +599,25 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
             continue;
         }
 
-        //test for constant or env var, if so evaluate it
-        if (firstChar == '$')
-        {
-            char* pend = NULL;
+        // test for constant or env var, if so evaluate it
+        if (firstChar == '$') {
+            char* pend = nullptr;
             int32_t indexSigned = (int32_t) strtol(placeholderValue.chars + 1, &pend, 10);
-            if (pend == placeholderValue.chars + 1)
-            {
+            if (pend == placeholderValue.chars + 1) {
                 // treat placeholder as an environment variable
                 char* envValue = getenv(placeholderValue.chars + 1);
-                if (envValue)
+                if (envValue) {
                     ffStrbufAppendS(buffer, envValue);
-                else
+                } else {
                     appendInvalidPlaceholder(buffer, "{", &placeholderValue, i, formatstr->length);
-            }
-            else
-            {
+                }
+            } else {
                 // treat placeholder as a constant
                 uint32_t index = (uint32_t) (indexSigned < 0 ? (int32_t) instance.config.display.constants.length + indexSigned : indexSigned - 1);
 
-                if (*pend != '\0' || instance.config.display.constants.length <= index)
+                if (*pend != '\0' || instance.config.display.constants.length <= index) {
                     appendInvalidPlaceholder(buffer, "{", &placeholderValue, i, formatstr->length);
-                else
-                {
+                } else {
                     FFstrbuf* item = FF_LIST_GET(FFstrbuf, instance.config.display.constants, index);
                     ffStrbufAppend(buffer, item);
                 }
@@ -292,122 +627,149 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
 
         char* pSep = placeholderValue.chars;
         char cSep = '\0';
-        while (*pSep && *pSep != ':' && *pSep != '<' && *pSep != '>' && *pSep != '~')
+        while (*pSep && *pSep != ':' && *pSep != '<' && *pSep != '>' && *pSep != '|' && *pSep != '~') {
             ++pSep;
-        if (*pSep)
-        {
+        }
+        if (*pSep) {
             cSep = *pSep;
             *pSep = '\0';
-        }
-        else
-        {
-            pSep = NULL;
+        } else {
+            pSep = nullptr;
         }
 
         uint32_t index = getArgumentIndex(placeholderValue.chars, numArgs, arguments);
 
         // test for invalid index
-        if (index == 0)
+        if (index == 0) {
             index = ++argCounter;
+        }
 
-        if (index > numArgs)
-        {
-            if (pSep) *pSep = cSep;
+        if (index > numArgs) {
+            if (pSep) {
+                *pSep = cSep;
+            }
             appendInvalidPlaceholder(buffer, "{", &placeholderValue, i, formatstr->length);
             continue;
         }
 
-        if (!cSep)
+        if (!cSep) {
             ffFormatAppendFormatArg(buffer, &arguments[index - 1]);
-        else if (cSep == '~')
-        {
+        } else if (cSep == '~') {
             FF_STRBUF_AUTO_DESTROY tempString = ffStrbufCreate();
             ffFormatAppendFormatArg(&tempString, &arguments[index - 1]);
+            FF_STRBUF_AUTO_DESTROY trailingEscape = ffStrbufCreate();
+            skipAnsiEscape(&tempString, buffer, &trailingEscape);
 
-            char* pEnd = NULL;
+            char* pEnd = nullptr;
             int32_t start = (int32_t) strtol(pSep + 1, &pEnd, 10);
-            if (start < 0)
+            if (start < 0) {
                 start = (int32_t) tempString.length + start;
-            if (start >= 0 && (uint32_t) start < tempString.length)
-            {
-                if (*pEnd == '\0')
+            }
+            if (start >= 0 && (uint32_t) start < tempString.length) {
+                if (*pEnd == '\0') {
                     ffStrbufAppendNS(buffer, tempString.length - (uint32_t) start, &tempString.chars[start]);
-                else if (*pEnd == ',')
-                {
+                } else if (*pEnd == ',') {
                     int32_t end = (int32_t) strtol(pEnd + 1, &pEnd, 10);
-                    if (!*pEnd)
-                    {
-                        if (end < 0)
+                    if (!*pEnd) {
+                        if (end < 0) {
                             end = (int32_t) tempString.length + end;
-                        if ((uint32_t) end > tempString.length)
+                        }
+                        if ((uint32_t) end > tempString.length) {
                             end = (int32_t) tempString.length;
-                        if (end > start)
+                        }
+                        if (end > start) {
                             ffStrbufAppendNS(buffer, (uint32_t) (end - start), &tempString.chars[start]);
+                        }
                     }
                 }
             }
 
-            if (*pEnd)
-            {
+            if (trailingEscape.length > 0) {
+                ffStrbufAppend(buffer, &trailingEscape);
+            }
+
+            if (*pEnd) {
                 *pSep = cSep;
                 appendInvalidPlaceholder(buffer, "{", &placeholderValue, i, formatstr->length);
                 continue;
             }
-        }
-        else
-        {
-            char* pEnd = NULL;
+        } else {
+            char* pEnd = nullptr;
             int32_t truncLength = (int32_t) strtol(pSep + 1, &pEnd, 10);
-            if (*pEnd != '\0')
-            {
+            if (*pEnd != '\0') {
                 *pSep = cSep;
                 appendInvalidPlaceholder(buffer, "{", &placeholderValue, i, formatstr->length);
                 continue;
             }
 
             bool ellipsis = false;
-            if (truncLength < 0)
-            {
+            if (truncLength < 0) {
                 ellipsis = true;
                 truncLength = -truncLength;
             }
 
             FF_STRBUF_AUTO_DESTROY tempString = ffStrbufCreate();
             ffFormatAppendFormatArg(&tempString, &arguments[index - 1]);
-            if (tempString.length == (uint32_t) truncLength)
+            FF_STRBUF_AUTO_DESTROY trailingEscape = ffStrbufCreate();
+            skipAnsiEscape(&tempString, buffer, &trailingEscape);
+
+            if (tempString.length == (uint32_t) truncLength) {
                 ffStrbufAppend(buffer, &tempString);
-            else if (tempString.length > (uint32_t) truncLength)
-            {
-                if (cSep == ':')
-                {
+            } else if (tempString.length > (uint32_t) truncLength) {
+                if (cSep == ':') {
                     ffStrbufSubstrBefore(&tempString, (uint32_t) truncLength);
                     ffStrbufTrimRightSpace(&tempString);
+                } else {
+                    ffStrbufSubstrBefore(&tempString, (uint32_t) (!ellipsis ? truncLength : truncLength - 1));
                 }
-                else
-                    ffStrbufSubstrBefore(&tempString, (uint32_t) (!ellipsis? truncLength : truncLength - 1));
                 ffStrbufAppend(buffer, &tempString);
 
-                if (ellipsis)
+                if (ellipsis) {
                     ffStrbufAppendS(buffer, "…");
-            }
-            else if (cSep == ':')
+                }
+            } else if (cSep == ':') {
                 ffStrbufAppend(buffer, &tempString);
-            else
-            {
-                if (cSep == '<')
-                {
+            } else {
+                if (cSep == '<') { // left align
                     ffStrbufAppend(buffer, &tempString);
                     ffStrbufAppendNC(buffer, (uint32_t) truncLength - tempString.length, ' ');
-                }
-                else
-                {
+                } else if (cSep == '>') { // right align
                     ffStrbufAppendNC(buffer, (uint32_t) truncLength - tempString.length, ' ');
                     ffStrbufAppend(buffer, &tempString);
+                } else if (cSep == '|') { // center align
+                    uint32_t padding = ((uint32_t) truncLength - tempString.length) / 2;
+                    ffStrbufAppendNC(buffer, padding, ' ');
+                    ffStrbufAppend(buffer, &tempString);
+                    ffStrbufAppendNC(buffer, (uint32_t) truncLength - tempString.length - padding, ' ');
                 }
             }
+
+            if (trailingEscape.length > 0) {
+                ffStrbufAppend(buffer, &trailingEscape);
+            }
         }
     }
 
-    if (!instance.config.display.pipe)
+    if (!instance.config.display.pipe) {
         ffStrbufAppendS(buffer, FASTFETCH_TEXT_MODIFIER_RESET);
+    }
+
+    return true;
+}
+
+bool ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t numArgs, const FFformatarg* arguments) {
+#if FF_HAVE_QUICKJS
+    if (ffStrbufStartsWithS(formatstr, "qjs:")) {
+        return parseQuickJSString(buffer, formatstr->chars + 4, formatstr->length - 4, numArgs, arguments);
+    }
+#endif
+
+#if FF_HAVE_LUA
+    if (ffStrbufStartsWithS(formatstr, "lua:")) {
+        // If outputFormat starts with "lua:", treat the rest as a Lua script
+        return parseLuaString(buffer, formatstr->chars + 4, formatstr->length - 4, numArgs, arguments);
+    }
+#endif
+
+    return parseFormatString(buffer, formatstr, numArgs, arguments);
 }

src/common/impl/frequency.c

@@ -1,24 +1,25 @@
 #include "common/frequency.h"
 
-bool ffFreqAppendNum(uint32_t mhz, FFstrbuf* result)
-{
-    if (mhz == 0)
+bool ffFreqAppendNum(uint32_t mhz, FFstrbuf* result) {
+    if (mhz == 0) {
         return false;
+    }
 
     const FFOptionsDisplay* options = &instance.config.display;
     bool spaceBeforeUnit = options->freqSpaceBeforeUnit != FF_SPACE_BEFORE_UNIT_NEVER;
     int8_t ndigits = options->freqNdigits;
 
-    if (ndigits >= 0)
-    {
+    if (ndigits >= 0) {
         ffStrbufAppendDouble(result, mhz / 1000., ndigits, true);
-        if (spaceBeforeUnit) ffStrbufAppendC(result, ' ');
+        if (spaceBeforeUnit) {
+            ffStrbufAppendC(result, ' ');
+        }
         ffStrbufAppendS(result, "GHz");
-    }
-    else
-    {
+    } else {
         ffStrbufAppendUInt(result, mhz);
-        if (spaceBeforeUnit) ffStrbufAppendC(result, ' ');
+        if (spaceBeforeUnit) {
+            ffStrbufAppendC(result, ' ');
+        }
         ffStrbufAppendS(result, "MHz");
     }
     return true;

src/common/impl/init.c

@@ -3,8 +3,8 @@
 #include "common/parsing.h"
 #include "common/thread.h"
 #include "common/textModifier.h"
+#include "common/strutil.h"
 #include "detection/displayserver/displayserver.h"
-#include "detection/terminaltheme/terminaltheme.h"
 #include "logo/logo.h"
 
 #include <stdlib.h>
@@ -16,248 +16,286 @@
 #else
     #include <signal.h>
 #endif
+#if __linux__
+    #include <linux/version.h>
+#endif
 
 FFinstance instance; // Global singleton
 
-static void initState(FFstate* state)
-{
+static void initState(FFstate* state) {
     state->logoWidth = 0;
     state->logoHeight = 0;
     state->keysHeight = 0;
-    state->terminalLightTheme = false;
     state->titleFqdn = false;
 
     ffPlatformInit(&state->platform);
     state->dynamicInterval = 0;
-
-    {
-        // don't enable bright color if the terminal is in light mode
-        FFTerminalThemeResult result;
-        if (ffDetectTerminalTheme(&result, true /* forceEnv for performance */) && !result.bg.dark)
-            state->terminalLightTheme = true;
-    }
 }
 
-static void defaultConfig(void)
-{
+static void defaultConfig(void) {
     ffOptionsInitLogo(&instance.config.logo);
     ffOptionsInitGeneral(&instance.config.general);
     ffOptionsInitDisplay(&instance.config.display);
 }
 
-void ffInitInstance(void)
-{
-    #ifdef _WIN32
-        // https://learn.microsoft.com/en-us/cpp/c-runtime-library/reference/setlocale-wsetlocale?source=recommendat>
-        setlocale(LC_ALL, ".UTF8");
-    #else
-        // Never use `setlocale(LC_ALL, "")`
-        setlocale(LC_TIME, "");
-    #endif
+#ifdef _WIN32
+static UINT oldCp = CP_UTF8;
+void resetConsoleCP(void) {
+    if (oldCp != CP_UTF8) {
+        SetConsoleOutputCP(oldCp);
+    }
+}
+#endif
+
+void ffInitInstance(void) {
+#ifdef _WIN32
+    // https://learn.microsoft.com/en-us/cpp/c-runtime-library/reference/setlocale-wsetlocale?source=recommendat>
+    setlocale(LC_ALL, ".UTF8");
+
+    HANDLE hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
+    DWORD mode = 0;
+    if (GetConsoleMode(hStdout, &mode)) {
+        SetConsoleMode(hStdout, mode | ENABLE_PROCESSED_OUTPUT | ENABLE_VIRTUAL_TERMINAL_PROCESSING);
+        oldCp = GetConsoleOutputCP();
+        if (oldCp != CP_UTF8) {
+            SetConsoleOutputCP(CP_UTF8);
+            atexit(resetConsoleCP);
+        }
+    }
+#else
+    // Never use `setlocale(LC_ALL, "")`
+    setlocale(LC_TIME, "");
+#endif
 
-    initState(&instance.state);
     defaultConfig();
+    initState(&instance.state);
+
+#ifdef _WIN32
+    instance.state.platform.initCP = oldCp;
+#endif
 }
 
-static volatile bool ffDisableLinewrap = true;
-static volatile bool ffHideCursor = true;
+static volatile bool ffDisableLinewrap = false;
+static volatile bool ffHideCursor = false;
 
-static void resetConsole(void)
-{
-    if(ffDisableLinewrap)
+static void resetConsole(void) {
+    if (ffDisableLinewrap) {
         fputs("\033[?7h", stdout);
+    }
 
-    if(ffHideCursor)
+    if (ffHideCursor) {
         fputs("\033[?25h", stdout);
+    }
 
-    #if defined(_WIN32)
-        fflush(stdout);
-    #endif
-
-    if(instance.state.dynamicInterval > 0)
+    if (instance.state.dynamicInterval > 0) {
         fputs("\033[?1049l", stdout); // Disable alternate buffer
+    }
+
+#if defined(_WIN32)
+    fflush(stdout);
+#endif
 }
 
 #ifdef _WIN32
-BOOL WINAPI consoleHandler(FF_MAYBE_UNUSED DWORD signal)
-{
+BOOL WINAPI consoleHandler([[maybe_unused]] DWORD signal) {
     resetConsole();
     exit(0);
 }
 #else
-static void exitSignalHandler(FF_MAYBE_UNUSED int signal)
-{
+static void exitSignalHandler([[maybe_unused]] int signal) {
     resetConsole();
     exit(0);
 }
 #endif
 
-void ffStart(void)
-{
+void ffStart(void) {
     ffDisableLinewrap = instance.config.display.disableLinewrap && !instance.config.display.pipe;
     ffHideCursor = instance.config.display.hideCursor && !instance.config.display.pipe;
 
-    #ifdef _WIN32
+#ifdef _WIN32
     SetErrorMode(SEM_FAILCRITICALERRORS);
-    if (instance.config.display.noBuffer)
-        setvbuf(stdout, NULL, _IONBF, 0);
-    else
-        setvbuf(stdout, NULL, _IOFBF, 4096);
+    if (instance.config.display.noBuffer) {
+        setvbuf(stdout, nullptr, _IONBF, 0);
+    } else {
+        setvbuf(stdout, nullptr, _IOFBF, 4096);
+    }
     SetConsoleCtrlHandler(consoleHandler, TRUE);
-    HANDLE hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
-    DWORD mode = 0;
-    GetConsoleMode(hStdout, &mode);
-    SetConsoleMode(hStdout, mode | ENABLE_PROCESSED_OUTPUT | ENABLE_VIRTUAL_TERMINAL_PROCESSING);
-    SetConsoleOutputCP(CP_UTF8);
-    #else
-    if (instance.config.display.noBuffer) setvbuf(stdout, NULL, _IONBF, 0);
-    struct sigaction action = { .sa_handler = exitSignalHandler };
-    sigaction(SIGINT, &action, NULL);
-    sigaction(SIGTERM, &action, NULL);
-    sigaction(SIGQUIT, &action, NULL);
+#else
+    if (instance.config.display.noBuffer) {
+        setvbuf(stdout, nullptr, _IONBF, 0);
+    }
+    struct sigaction action;
+    sigemptyset(&action.sa_mask);
+    action.sa_flags = 0;
+    action.sa_handler = exitSignalHandler;
+    sigaction(SIGINT, &action, nullptr);
+    sigaction(SIGTERM, &action, nullptr);
+    sigaction(SIGQUIT, &action, nullptr);
     sigset_t newmask;
     sigemptyset(&newmask);
     sigaddset(&newmask, SIGCHLD);
-    sigprocmask(SIG_BLOCK, &newmask, NULL);
-    #endif
+    sigprocmask(SIG_BLOCK, &newmask, nullptr);
+#endif
 
-    //reset everything to default before we start printing
-    if(!instance.config.display.pipe)
+    // reset everything to default before we start printing
+    if (!instance.config.display.pipe) {
         fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
+    }
 
-    if(ffHideCursor)
+    if (ffHideCursor) {
         fputs("\033[?25l", stdout);
+    }
 
-    if(ffDisableLinewrap)
+    if (ffDisableLinewrap) {
         fputs("\033[?7l", stdout);
+    }
 
-    if(instance.state.dynamicInterval > 0)
-    {
+    if (instance.state.dynamicInterval > 0) {
         fputs("\033[?1049h\033[H", stdout); // Enable alternate buffer
         fflush(stdout);
     }
 }
 
-void ffFinish(void)
-{
+void ffFinish(void) {
     resetConsole();
 }
 
-static void destroyConfig(void)
-{
+static void destroyConfig(void) {
     ffOptionsDestroyLogo(&instance.config.logo);
     ffOptionsDestroyGeneral(&instance.config.general);
     ffOptionsDestroyDisplay(&instance.config.display);
 }
 
-static void destroyState(void)
-{
+static void destroyState(void) {
     ffPlatformDestroy(&instance.state.platform);
 }
 
-void ffDestroyInstance(void)
-{
+void ffDestroyInstance(void) {
     destroyConfig();
     destroyState();
 }
 
-//Must be in a file compiled with the libfastfetch target, because the FF_HAVE* macros are not defined for the executable targets
-void ffListFeatures(void)
-{
+#if FF_HAVE_LUA
+    #include <lua.h>
+#endif
+#if FF_HAVE_QUICKJS
+    #include <quickjs.h>
+#endif
+
+// Must be in a file compiled with the libfastfetch target, because the FF_HAVE* macros are not defined for the executable targets
+void ffListFeatures(void) {
     fputs(
-        #if FF_HAVE_THREADS
-            "threads\n"
-        #endif
-        #if FF_HAVE_VULKAN
-            "vulkan\n"
-        #endif
-        #if FF_HAVE_WAYLAND
-            "wayland\n"
-        #endif
-        #if FF_HAVE_XCB_RANDR
-            "xcb-randr\n"
-        #endif
-        #if FF_HAVE_XRANDR
-            "xrandr\n"
-        #endif
-        #if FF_HAVE_DRM
-            "drm\n"
-        #endif
-        #if FF_HAVE_DRM_AMDGPU
-            "drm_amdgpu\n"
-        #endif
-        #if FF_HAVE_GIO
-            "gio\n"
-        #endif
-        #if FF_HAVE_DCONF
-            "dconf\n"
-        #endif
-        #if FF_HAVE_DBUS
-            "dbus\n"
-        #endif
-        #if FF_HAVE_IMAGEMAGICK7
-            "imagemagick7\n"
-        #endif
-        #if FF_HAVE_IMAGEMAGICK6
-            "imagemagick6\n"
-        #endif
-        #if FF_HAVE_CHAFA
-            "chafa\n"
-        #endif
-        #if FF_HAVE_ZLIB
-            "zlib\n"
-        #endif
-        #if FF_HAVE_SQLITE3
-            "sqlite3\n"
-        #endif
-        #if FF_HAVE_RPM
-            "rpm\n"
-        #endif
-        #if FF_HAVE_EGL
-            "egl\n"
-        #endif
-        #if FF_HAVE_GLX
-            "glx\n"
-        #endif
-        #if FF_HAVE_OPENCL
-            "opencl\n"
-        #endif
-        #if FF_HAVE_FREETYPE
-            "freetype\n"
-        #endif
-        #if FF_HAVE_PULSE
-            "libpulse\n"
-        #endif
-        #if FF_HAVE_DDCUTIL
-            "libddcutil\n"
-        #endif
-        #if FF_HAVE_ELF || __sun || (__FreeBSD__ && !__DragonFly__) || __OpenBSD__ || __NetBSD__
-            "libelf\n"
-        #endif
-        #if FF_HAVE_LIBZFS
-            "libzfs\n"
-        #endif
-        #if FF_HAVE_DIRECTX_HEADERS
-            "Directx Headers\n"
-        #endif
-        #if FF_USE_SYSTEM_YYJSON
-            "System yyjson\n"
-        #endif
-        #if FF_HAVE_LINUX_VIDEODEV2
-            "linux/videodev2\n"
-        #endif
-        #if FF_HAVE_LINUX_WIRELESS
-            "linux/wireless\n"
-        #endif
-        #if FF_HAVE_EMBEDDED_PCIIDS
-            "Embedded pciids\n"
-        #endif
-        #if FF_WIN7_COMPAT
-            "Windows 7 Compatibility\n"
-        #endif
-        #if FF_APPLE_MEMSIZE_USABLE
-            "Apple memsize_usable\n"
-        #endif
-        ""
-    , stdout);
+#if __linux__
+        "linux-headers " FF_STR(LINUX_VERSION_MAJOR) "." FF_STR(LINUX_VERSION_PATCHLEVEL) "." FF_STR(LINUX_VERSION_SUBLEVEL) "\n"
+#endif
+#if FF_HAVE_THREADS
+        "threads\n"
+#endif
+#if FF_HAVE_VULKAN
+        "vulkan\n"
+#endif
+#if FF_HAVE_WAYLAND
+        "wayland\n"
+#endif
+#if FF_HAVE_XCB_RANDR
+        "xcb-randr\n"
+#endif
+#if FF_HAVE_XRANDR
+        "xrandr\n"
+#endif
+#if FF_HAVE_DRM
+        "drm\n"
+#endif
+#if FF_HAVE_GIO
+        "gio\n"
+#endif
+#if FF_HAVE_DCONF
+        "dconf\n"
+#endif
+#if FF_HAVE_EET
+        "eet\n"
+#endif
+#if FF_HAVE_DBUS
+        "dbus\n"
+#endif
+#if FF_HAVE_IMAGEMAGICK7
+        "imagemagick7\n"
+#endif
+#if FF_HAVE_IMAGEMAGICK6
+        "imagemagick6\n"
+#endif
+#if FF_HAVE_CHAFA
+        "chafa\n"
+#endif
+#if FF_HAVE_ZLIB
+        "zlib\n"
+#endif
+#if FF_HAVE_SQLITE3
+        "sqlite3\n"
+#endif
+#if FF_HAVE_RPM
+        "rpm\n"
+#endif
+#if FF_HAVE_EGL
+        "egl\n"
+#endif
+#if FF_HAVE_GLX
+        "glx\n"
+#endif
+#if FF_HAVE_OPENCL
+        "opencl\n"
+#endif
+#if FF_HAVE_FREETYPE
+        "freetype\n"
+#endif
+#if FF_HAVE_PULSE
+        "libpulse\n"
+#endif
+#if FF_HAVE_DDCUTIL
+        "libddcutil\n"
+#endif
+#if FF_HAVE_ELF || __sun || (__FreeBSD__ && !__DragonFly__) || __OpenBSD__ || __NetBSD__
+        "libelf\n"
+#endif
+#if FF_HAVE_LIBZFS
+        "libzfs\n"
+#endif
+#if FF_HAVE_VADRM
+        "va-drm\n"
+#endif
+#if FF_HAVE_VAX11
+        "va-x11\n"
+#endif
+#if FF_HAVE_VDPAU
+        "vdpau\n"
+#endif
+#if FF_USE_SYSTEM_YYJSON
+        "System yyjson\n"
+#endif
+#if FF_HAVE_LINUX_VIDEODEV2
+        "linux/videodev2\n"
+#endif
+#if FF_HAVE_EMBEDDED_PCIIDS
+        "Embedded pciids\n"
+#endif
+#if FF_ENABLE_WCWIDTH
+        "Embedded wcwidth\n"
+#endif
+#if FF_HAVE_WINRT
+        "WinRT headers\n"
+#endif
+#if FF_WIN81_COMPAT
+        "Windows 8.1 Compatibility\n"
+#endif
+#if FF_APPLE_MEMSIZE_USABLE
+        "Apple memsize_usable\n"
+#endif
+#if FF_HAVE_LUA
+        LUA_VERSION "\n"
+#endif
+#if FF_HAVE_QUICKJS
+        "QuickJS " FF_STR(QJS_VERSION_MAJOR) "." FF_STR(QJS_VERSION_MINOR) "." FF_STR(QJS_VERSION_PATCH) QJS_VERSION_SUFFIX "\n"
+#endif
+        "",
+        stdout);
 }

src/common/impl/io_unix.c

@@ -1,6 +1,6 @@
 #include "common/io.h"
 #include "fastfetch.h"
-#include "common/stringUtils.h"
+#include "common/strutil.h"
 #include "common/time.h"
 
 #include <fcntl.h>
@@ -8,9 +8,9 @@
 #include <dirent.h>
 #include <errno.h>
 #ifndef __APPLE__
-#include <poll.h>
+    #include <poll.h>
 #else
-#include <sys/select.h>
+    #include <sys/select.h>
 #endif
 
 #if FF_HAVE_WORDEXP
@@ -19,206 +19,166 @@
     #include <glob.h>
 #endif
 
-static void createSubfolders(const char* fileName)
-{
+static void createSubfolders(const char* fileName) {
     FF_STRBUF_AUTO_DESTROY path = ffStrbufCreate();
 
-    const char *token = NULL;
-    while((token = strchr(fileName, '/')) != NULL)
-    {
-        ffStrbufAppendNS(&path, (uint32_t)(token - fileName + 1), fileName);
+    const char* token = nullptr;
+    while ((token = strchr(fileName, '/')) != nullptr) {
+        ffStrbufAppendNS(&path, (uint32_t) (token - fileName + 1), fileName);
         mkdir(path.chars, S_IRWXU | S_IRGRP | S_IROTH);
         fileName = token + 1;
     }
 }
 
-bool ffWriteFileData(const char* fileName, size_t dataSize, const void* data)
-{
+bool ffWriteFileData(const char* fileName, size_t dataSize, const void* data) {
     int openFlagsModes = O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC;
     mode_t openFlagsRights = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
 
-    int FF_AUTO_CLOSE_FD fd = open(fileName, openFlagsModes, openFlagsRights);
-    if(fd == -1)
-    {
-        if (errno == ENOENT)
-        {
+    FF_AUTO_CLOSE_FD int fd = open(fileName, openFlagsModes, openFlagsRights);
+    if (fd == -1) {
+        if (errno == ENOENT) {
             createSubfolders(fileName);
             fd = open(fileName, openFlagsModes, openFlagsRights);
-            if(fd == -1)
+            if (fd == -1) {
                 return false;
-        }
-        else
+            }
+        } else {
             return false;
+        }
     }
 
     return write(fd, data, dataSize) > 0;
 }
 
-static inline void readWithLength(int fd, FFstrbuf* buffer, uint32_t length)
-{
+static inline void readWithLength(int fd, FFstrbuf* buffer, uint32_t length) {
     ffStrbufEnsureFixedLengthFree(buffer, length);
     ssize_t bytesRead = 0;
-    while(
-        length > 0 && (bytesRead = read(fd, buffer->chars + buffer->length, length)) > 0
-    ) {
+    while (
+        length > 0 && (bytesRead = read(fd, buffer->chars + buffer->length, length)) > 0) {
         buffer->length += (uint32_t) bytesRead;
         length -= (uint32_t) bytesRead;
     }
 }
 
-static inline void readUntilEOF(int fd, FFstrbuf* buffer)
-{
+static inline void readUntilEOF(int fd, FFstrbuf* buffer) {
     ffStrbufEnsureFree(buffer, 31);
     uint32_t available = ffStrbufGetFree(buffer);
     ssize_t bytesRead = 0;
-    while(
-        (bytesRead = read(fd, buffer->chars + buffer->length, available)) > 0
-    ) {
+    while (
+        (bytesRead = read(fd, buffer->chars + buffer->length, available)) > 0) {
         buffer->length += (uint32_t) bytesRead;
-        if((uint32_t) bytesRead == available)
+        if ((uint32_t) bytesRead == available) {
             ffStrbufEnsureFree(buffer, buffer->allocated - 1); // Doubles capacity every round. -1 for the null byte.
+        }
         available = ffStrbufGetFree(buffer);
     }
 }
 
-bool ffAppendFDBuffer(int fd, FFstrbuf* buffer)
-{
+bool ffAppendFDBuffer(int fd, FFstrbuf* buffer) {
     struct stat fileInfo;
-    if(fstat(fd, &fileInfo) != 0)
+    if (fstat(fd, &fileInfo) != 0) {
         return false;
+    }
 
-    if (fileInfo.st_size > 0)
-        readWithLength(fd, buffer, (uint32_t)fileInfo.st_size);
-    else
+    if (fileInfo.st_size > 0) {
+        readWithLength(fd, buffer, (uint32_t) fileInfo.st_size);
+    } else {
         readUntilEOF(fd, buffer);
+    }
 
     buffer->chars[buffer->length] = '\0';
 
     return buffer->length > 0;
 }
 
-ssize_t ffReadFileData(const char* fileName, size_t dataSize, void* data)
-{
-    int FF_AUTO_CLOSE_FD fd = open(fileName, O_RDONLY | O_CLOEXEC);
-    if(fd == -1)
-        return -1;
-
-    return ffReadFDData(fd, dataSize, data);
-}
-
-ssize_t ffReadFileDataRelative(int dfd, const char* fileName, size_t dataSize, void* data)
-{
-    int FF_AUTO_CLOSE_FD fd = openat(dfd, fileName, O_RDONLY | O_CLOEXEC);
-    if(fd == -1)
-        return -1;
-
-    return ffReadFDData(fd, dataSize, data);
-}
-
-bool ffAppendFileBuffer(const char* fileName, FFstrbuf* buffer)
-{
-    int FF_AUTO_CLOSE_FD fd = open(fileName, O_RDONLY | O_CLOEXEC);
-    if(fd == -1)
-        return false;
-
-    return ffAppendFDBuffer(fd, buffer);
-}
-
-bool ffAppendFileBufferRelative(int dfd, const char* fileName, FFstrbuf* buffer)
-{
-    int FF_AUTO_CLOSE_FD fd = openat(dfd, fileName, O_RDONLY | O_CLOEXEC);
-    if(fd == -1)
-        return false;
-
-    return ffAppendFDBuffer(fd, buffer);
-}
-
-bool ffPathExpandEnv(const char* in, FFstrbuf* out)
-{
+bool ffPathExpandEnv(const char* in, FFstrbuf* out) {
     bool result = false;
 
-    #if FF_HAVE_WORDEXP
+#if FF_HAVE_WORDEXP
 
     wordexp_t exp;
-    if (wordexp(in, &exp, 0) != 0) // WARN: 0 = no safety flags; command substitution allowed
+    if (wordexp(in, &exp, 0) != 0) { // WARN: 0 = no safety flags; command substitution allowed
         return false;
+    }
 
-    if (exp.we_wordc >= 1)
-    {
+    if (exp.we_wordc >= 1) {
         result = true;
         ffStrbufSetS(out, exp.we_wordv[exp.we_wordc > 1 ? ffTimeGetNow() % exp.we_wordc : 0]);
     }
 
     wordfree(&exp);
 
-    #else
+#else
 
     glob_t gb;
     if (glob(in, GLOB_NOSORT
-            #ifdef GLOB_TILDE
-            | GLOB_TILDE
-            #endif
-            #ifdef GLOB_BRACE
-            | GLOB_BRACE
-            #endif
-        , NULL, &gb) != 0)
+    #ifdef GLOB_TILDE
+                | GLOB_TILDE
+    #endif
+    #ifdef GLOB_BRACE
+                | GLOB_BRACE
+    #endif
+            ,
+            nullptr,
+            &gb) != 0)
         return false;
 
-    if (gb.gl_pathc >= 1)
-    {
+    if (gb.gl_pathc >= 1) {
         result = true;
         ffStrbufSetS(out, gb.gl_pathv[gb.gl_pathc > 1 ? ffTimeGetNow() % (unsigned) gb.gl_pathc : 0]);
     }
 
     globfree(&gb);
 
-    #endif
+#endif
 
     return result;
 }
 
 static int ftty = -1;
 static struct termios oldTerm;
-void restoreTerm(void)
-{
+void restoreTerm(void) {
     tcsetattr(ftty, TCSAFLUSH, &oldTerm);
 }
 
-const char* ffGetTerminalResponse(const char* request, int nParams, const char* format, ...)
-{
-    if (ftty < 0)
-    {
+const char* ffGetTerminalResponse(const char* request, int nParams, const char* format, ...) {
+    if (ftty < 0) {
         ftty = open("/dev/tty", O_RDWR | O_NOCTTY | O_CLOEXEC);
-        if (ftty < 0)
+        if (ftty < 0) {
             return "open(\"/dev/tty\", O_RDWR | O_NOCTTY | O_CLOEXEC) failed";
+        }
 
-        if(tcgetattr(ftty, &oldTerm) == -1)
+        if (tcgetattr(ftty, &oldTerm) == -1) {
             return "tcgetattr(STDIN_FILENO, &oldTerm) failed";
+        }
 
         struct termios newTerm = oldTerm;
         newTerm.c_lflag &= (tcflag_t) ~(ICANON | ECHO);
-        if(tcsetattr(ftty, TCSAFLUSH, &newTerm) == -1)
+        if (tcsetattr(ftty, TCSAFLUSH, &newTerm) == -1) {
             return "tcsetattr(STDIN_FILENO, TCSAFLUSH, &newTerm)";
+        }
         atexit(restoreTerm);
     }
 
     ffWriteFDData(ftty, strlen(request), request);
 
-    //Give the terminal some time to respond
-    #ifndef __APPLE__
-    if(poll(&(struct pollfd) { .fd = ftty, .events = POLLIN }, 1, FF_IO_TERM_RESP_WAIT_MS) <= 0)
+// Give the terminal some time to respond
+#ifndef __APPLE__
+    if (poll(&(struct pollfd) { .fd = ftty, .events = POLLIN }, 1, FF_IO_TERM_RESP_WAIT_MS) <= 0) {
         return "poll(/dev/tty) timeout or failed";
-    #else
+    }
+#else
     {
         // On macOS, poll(/dev/tty) always returns immediately
         // See also https://nathancraddock.com/blog/macos-dev-tty-polling/
         fd_set rd;
         FD_ZERO(&rd);
         FD_SET(ftty, &rd);
-        if(select(ftty + 1, &rd, NULL, NULL, &(struct timeval) { .tv_sec = FF_IO_TERM_RESP_WAIT_MS / 1000, .tv_usec = (FF_IO_TERM_RESP_WAIT_MS % 1000) * 1000 }) <= 0)
+        if (select(ftty + 1, &rd, nullptr, nullptr, &(struct timeval) { .tv_sec = FF_IO_TERM_RESP_WAIT_MS / 1000, .tv_usec = (FF_IO_TERM_RESP_WAIT_MS % 1000) * 1000 }) <= 0) {
             return "select(/dev/tty) timeout or failed";
+        }
     }
-    #endif
+#endif
 
     char buffer[1024];
     size_t bytesRead = 0;
@@ -226,12 +186,10 @@ const char* ffGetTerminalResponse(const char* request, int nParams, const char*
     va_list args;
     va_start(args, format);
 
-    while (true)
-    {
+    while (true) {
         ssize_t nRead = read(ftty, buffer + bytesRead, sizeof(buffer) - bytesRead - 1);
 
-        if (nRead <= 0)
-        {
+        if (nRead <= 0) {
             va_end(args);
             return "read(STDIN_FILENO, buffer, sizeof(buffer) - 1) failed";
         }
@@ -244,36 +202,36 @@ const char* ffGetTerminalResponse(const char* request, int nParams, const char*
         int ret = vsscanf(buffer, format, cargs);
         va_end(cargs);
 
-        if (ret <= 0)
-        {
+        if (ret <= 0) {
             va_end(args);
             return "vsscanf(buffer, format, args) failed";
         }
-        if (ret >= nParams)
+        if (ret >= nParams) {
             break;
+        }
     }
 
     va_end(args);
 
-    return NULL;
+    return nullptr;
 }
 
-bool ffSuppressIO(bool suppress)
-{
-    #ifndef NDEBUG
-    if (instance.config.display.debugMode)
+bool ffSuppressIO(bool suppress) {
+#ifndef NDEBUG
+    if (instance.config.display.debugMode) {
         return false;
-    #endif
+    }
+#endif
 
     static bool init = false;
     static int origOut = -1;
     static int origErr = -1;
     static int nullFile = -1;
 
-    if(!init)
-    {
-        if(!suppress)
+    if (!init) {
+        if (!suppress) {
             return true;
+        }
 
         origOut = dup(STDOUT_FILENO);
         origErr = dup(STDERR_FILENO);
@@ -281,8 +239,9 @@ bool ffSuppressIO(bool suppress)
         init = true;
     }
 
-    if(nullFile == -1)
+    if (nullFile == -1) {
         return false;
+    }
 
     fflush(stdout);
     fflush(stderr);
@@ -292,47 +251,49 @@ bool ffSuppressIO(bool suppress)
     return true;
 }
 
-void listFilesRecursively(uint32_t baseLength, FFstrbuf* folder, uint8_t indentation, const char* folderName, bool pretty)
-{
-    FF_AUTO_CLOSE_FD int dfd = open(folder->chars, O_RDONLY | O_CLOEXEC);
-    if (dfd < 0)
+void listFilesRecursively(uint32_t baseLength, FFstrbuf* folder, uint8_t indentation, const char* folderName, bool pretty) {
+    int dfd = open(folder->chars, O_RDONLY | O_CLOEXEC | O_DIRECTORY); // Ownership of dfd will be transformed to dir
+    if (dfd < 0) {
         return;
+    }
 
-    DIR* dir = fdopendir(dfd);
-    if(dir == NULL)
-        return;
+    FF_AUTO_CLOSE_DIR DIR* dir = fdopendir(dfd);
+    if (dir == nullptr) {
+        close(dfd);
+        return; // Should not happen
+    }
 
     uint32_t folderLength = folder->length;
 
-    if(pretty && folderName != NULL)
-    {
-        for(uint8_t i = 0; i < indentation - 1; i++)
+    if (pretty && folderName != nullptr) {
+        for (uint8_t i = 0; i < indentation - 1; i++) {
             fputs("  | ", stdout);
+        }
         printf("%s/\n", folderName);
     }
 
     struct dirent* entry;
 
-    while((entry = readdir(dir)) != NULL)
-    {
-        if(entry->d_name[0] == '.') // skip hidden files
+    while ((entry = readdir(dir)) != nullptr) {
+        if (entry->d_name[0] == '.') { // skip hidden files
             continue;
+        }
 
         bool isDir = false;
 #if !defined(__sun) && !defined(__HAIKU__)
-        if(entry->d_type != DT_UNKNOWN && entry->d_type != DT_LNK)
+        if (entry->d_type != DT_UNKNOWN && entry->d_type != DT_LNK) {
             isDir = entry->d_type == DT_DIR;
-        else
+        } else
 #endif
         {
             struct stat stbuf;
-            if (fstatat(dfd, entry->d_name, &stbuf, 0) < 0)
+            if (fstatat(dfd, entry->d_name, &stbuf, 0) < 0) {
                 isDir = false;
-            else
+            } else {
                 isDir = S_ISDIR(stbuf.st_mode);
+            }
         }
-        if (isDir)
-        {
+        if (isDir) {
             ffStrbufAppendS(folder, entry->d_name);
             ffStrbufAppendC(folder, '/');
             listFilesRecursively(baseLength, folder, (uint8_t) (indentation + 1), entry->d_name, pretty);
@@ -340,39 +301,33 @@ void listFilesRecursively(uint32_t baseLength, FFstrbuf* folder, uint8_t indenta
             continue;
         }
 
-        if (pretty)
-        {
-            for(uint8_t i = 0; i < indentation; i++)
+        if (pretty) {
+            for (uint8_t i = 0; i < indentation; i++) {
                 fputs("  | ", stdout);
-        }
-        else
-        {
+            }
+        } else {
             fputs(folder->chars + baseLength, stdout);
         }
 
         puts(entry->d_name);
     }
-
-    closedir(dir);
 }
 
-void ffListFilesRecursively(const char* path, bool pretty)
-{
+void ffListFilesRecursively(const char* path, bool pretty) {
     FF_STRBUF_AUTO_DESTROY folder = ffStrbufCreateS(path);
     ffStrbufEnsureEndsWithC(&folder, '/');
-    listFilesRecursively(folder.length, &folder, 0, NULL, pretty);
+    listFilesRecursively(folder.length, &folder, 0, nullptr, pretty);
 }
 
-FFNativeFD ffGetNullFD(void)
-{
+FFNativeFD ffGetNullFD(void) {
     static FFNativeFD hNullFile = -1;
-    if (hNullFile != -1)
+    if (hNullFile != -1) {
         return hNullFile;
+    }
     hNullFile = open("/dev/null", O_WRONLY | O_CLOEXEC);
     return hNullFile;
 }
 
-bool ffRemoveFile(const char* fileName)
-{
+bool ffRemoveFile(const char* fileName) {
     return unlink(fileName) == 0;
 }