commit 359e6c8e92610b4be3fff03abba02b02e154e3e8 Author: Elisiei Yehorov Date: Thu Apr 2 20:08:25 2026 +0200 chore: ok diff --git a/.envrc b/.envrc new file mode 100644 index 0000000..3550a30 --- /dev/null +++ b/.envrc @@ -0,0 +1 @@ +use flake diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..70282d1 --- /dev/null +++ b/.gitignore @@ -0,0 +1,35 @@ +# If you prefer the allow list template instead of the deny list, see community template: +# https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore +# +# Binaries for programs and plugins +*.exe +*.exe~ +*.dll +*.so +*.dylib + +# Test binary, built with `go test -c` +*.test + +# Code coverage profiles and other test artifacts +*.out +coverage.* +*.coverprofile +profile.cov + +# Dependency directories (remove the comment below to include it) +# vendor/ + +# Go workspace file +go.work +go.work.sum + +# env file +.env +.direnv + +bin/ + +# Editor/IDE +# .idea/ +# .vscode/ diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..6ca207e --- /dev/null +++ b/LICENSE @@ -0,0 +1,122 @@ +Creative Commons Legal Code + +CC0 1.0 Universal + + CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE + LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN + ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS + INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES + REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS + PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM + THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED + HEREUNDER. + +Statement of Purpose + +The laws of most jurisdictions throughout the world automatically confer +exclusive Copyright and Related Rights (defined below) upon the creator +and subsequent owner(s) (each and all, an "owner") of an original work of +authorship and/or a database (each, a "Work"). + +Certain owners wish to permanently relinquish those rights to a Work for +the purpose of contributing to a commons of creative, cultural and +scientific works ("Commons") that the public can reliably and without fear +of later claims of infringement build upon, modify, incorporate in other +works, reuse and redistribute as freely as possible in any form whatsoever +and for any purposes, including without limitation commercial purposes. +These owners may contribute to the Commons to promote the ideal of a free +culture and the further production of creative, cultural and scientific +works, or to gain reputation or greater distribution for their Work in +part through the use and efforts of others. + +For these and/or other purposes and motivations, and without any +expectation of additional consideration or compensation, the person +associating CC0 with a Work (the "Affirmer"), to the extent that he or she +is an owner of Copyright and Related Rights in the Work, voluntarily +elects to apply CC0 to the Work and publicly distribute the Work under its +terms, with knowledge of his or her Copyright and Related Rights in the +Work and the meaning and intended legal effect of CC0 on those rights. + +1. Copyright and Related Rights. A Work made available under CC0 may be +protected by copyright and related or neighboring rights ("Copyright and +Related Rights"). Copyright and Related Rights include, but are not +limited to, the following: + + i. the right to reproduce, adapt, distribute, perform, display, + communicate, and translate a Work; + ii. moral rights retained by the original author(s) and/or performer(s); +iii. publicity and privacy rights pertaining to a person's image or + likeness depicted in a Work; + iv. rights protecting against unfair competition in regards to a Work, + subject to the limitations in paragraph 4(a), below; + v. rights protecting the extraction, dissemination, use and reuse of data + in a Work; + vi. database rights (such as those arising under Directive 96/9/EC of the + European Parliament and of the Council of 11 March 1996 on the legal + protection of databases, and under any national implementation + thereof, including any amended or successor version of such + directive); and +vii. other similar, equivalent or corresponding rights throughout the + world based on applicable law or treaty, and any national + implementations thereof. + +2. Waiver. To the greatest extent permitted by, but not in contravention +of, applicable law, Affirmer hereby overtly, fully, permanently, +irrevocably and unconditionally waives, abandons, and surrenders all of +Affirmer's Copyright and Related Rights and associated claims and causes +of action, whether now known or unknown (including existing as well as +future claims and causes of action), in the Work (i) in all territories +worldwide, (ii) for the maximum duration provided by applicable law or +treaty (including future time extensions), (iii) in any current or future +medium and for any number of copies, and (iv) for any purpose whatsoever, +including without limitation commercial, advertising or promotional +purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each +member of the public at large and to the detriment of Affirmer's heirs and +successors, fully intending that such Waiver shall not be subject to +revocation, rescission, cancellation, termination, or any other legal or +equitable action to disrupt the quiet enjoyment of the Work by the public +as contemplated by Affirmer's express Statement of Purpose. + +3. Public License Fallback. Should any part of the Waiver for any reason +be judged legally invalid or ineffective under applicable law, then the +Waiver shall be preserved to the maximum extent permitted taking into +account Affirmer's express Statement of Purpose. In addition, to the +extent the Waiver is so judged Affirmer hereby grants to each affected +person a royalty-free, non transferable, non sublicensable, non exclusive, +irrevocable and unconditional license to exercise Affirmer's Copyright and +Related Rights in the Work (i) in all territories worldwide, (ii) for the +maximum duration provided by applicable law or treaty (including future +time extensions), (iii) in any current or future medium and for any number +of copies, and (iv) for any purpose whatsoever, including without +limitation commercial, advertising or promotional purposes (the +"License"). The License shall be deemed effective as of the date CC0 was +applied by Affirmer to the Work. Should any part of the License for any +reason be judged legally invalid or ineffective under applicable law, such +partial invalidity or ineffectiveness shall not invalidate the remainder +of the License, and in such case Affirmer hereby affirms that he or she +will not (i) exercise any of his or her remaining Copyright and Related +Rights in the Work or (ii) assert any associated claims and causes of +action with respect to the Work, in either case contrary to Affirmer's +express Statement of Purpose. + +4. Limitations and Disclaimers. + + a. No trademark or patent rights held by Affirmer are waived, abandoned, + surrendered, licensed or otherwise affected by this document. + b. Affirmer offers the Work as-is and makes no representations or + warranties of any kind concerning the Work, express, implied, + statutory or otherwise, including without limitation warranties of + title, merchantability, fitness for a particular purpose, non + infringement, or the absence of latent or other defects, accuracy, or + the present or absence of errors, whether or not discoverable, all to + the greatest extent permissible under applicable law. + c. Affirmer disclaims responsibility for clearing rights of other persons + that may apply to the Work or any use thereof, including without + limitation any person's Copyright and Related Rights in the Work. + Further, Affirmer disclaims responsibility for obtaining any necessary + consents, permissions or other rights required for any use of the + Work. + d. Affirmer understands and acknowledges that Creative Commons is not a + party to this document and has no duty or obligation with respect to + this CC0 or use of the Work. + diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..1fe415c --- /dev/null +++ b/Makefile @@ -0,0 +1,15 @@ +BIN := ./bin +BENCH := $(BIN)/bench +PLOT := $(BIN)/plot + +.PHONY: all build clean + +all: build bench plot + +build: + @mkdir -p $(BIN) + go build -o $(BENCH) ./cmd/bench + go build -o $(PLOT) ./cmd/plot + +clean: + rm -rf $(BIN) results diff --git a/README.md b/README.md new file mode 100644 index 0000000..007f902 --- /dev/null +++ b/README.md @@ -0,0 +1,23 @@ +# sysbench + +system fetch benchmarks + +[results](results) + +## tested fetches + +*via nixpkgs*: fastfetch, uwufetch, pfetch, microfetch, maxfetch, yafetch, bunnyfetch, tinyfetch, leaf, nitch, disfetch +*locally installed*: novofetch, unfetch, gotcha, ohmyfetch + +## usage + +``` +git clone bullshit... +make build +./bin/bench -targets="fastfetch, uwufetch, pfetch, microfetch, maxfetch, yafetch, bunnyfetch, tinyfetch, leaf, nitch, disfetch" +./bin/plot +``` + +# license + +CC0 1.0 diff --git a/cmd/bench/main.go b/cmd/bench/main.go new file mode 100644 index 0000000..c946f53 --- /dev/null +++ b/cmd/bench/main.go @@ -0,0 +1,84 @@ +package main + +import ( + "flag" + "fmt" + "log" + "os" + "os/exec" + "path/filepath" + "strings" + "time" +) + +const ( + warmup = 2 + runs = 10 +) + +// you'll need to install all fetches :P +// it's easier with nix shell btwww +func main() { + targetsFlag := flag.String("targets", "", "comma-separated list of commands to benchmark") + flag.Parse() + + if *targetsFlag == "" { + log.Fatal("please provide at least one target via -targets") + } + + targets := parseTargets(*targetsFlag) + + dir := filepath.Join("results", time.Now().Format("2006-01-02")) + if err := os.MkdirAll(dir, 0o755); err != nil { + log.Fatal(err) + } + + jsonOut := filepath.Join(dir, "results.json") + mdOut := filepath.Join(dir, "results.md") + + args := buildArgs(targets, jsonOut, mdOut) + + cmd := exec.Command("hyperfine", args...) + cmd.Stdout = os.Stdout + cmd.Stderr = os.Stderr + + fmt.Printf("benchmarking %d targets (%d warmup, %d runs each)\n", len(targets), warmup, runs) + fmt.Printf("output: %s\n", dir) + + if err := cmd.Run(); err != nil { + log.Fatalf("hyperfine: %v", err) + } + + fmt.Printf("results written to %s\n", dir) +} + +func parseTargets(input string) []string { + parts := strings.Split(input, ",") + var targets []string + for _, p := range parts { + p = strings.TrimSpace(p) + if p != "" { + targets = append(targets, p) + } + } + return targets +} + +func buildArgs(targets []string, jsonOut, mdOut string) []string { + args := []string{ + "--warmup", fmt.Sprintf("%d", warmup), + "--runs", fmt.Sprintf("%d", runs), + "--export-json", jsonOut, + "--export-markdown", mdOut, + "--ignore-failure", + "--shell", "none", + "--style", "full", + "--sort", "mean-time", + } + + for _, t := range targets { + args = append(args, t) + } + + return args +} diff --git a/cmd/plot/main.go b/cmd/plot/main.go new file mode 100644 index 0000000..7bbbf04 --- /dev/null +++ b/cmd/plot/main.go @@ -0,0 +1,187 @@ +package main + +import ( + "encoding/json" + "fmt" + "log" + "math" + "os" + "os/exec" + "path/filepath" + "sort" + "strings" + "time" + + "codeberg.org/elisiei/sysbench/internal/hyperfine" +) + +const ( + svgW = 900 + padTop = 48 + padBottom = 80 + padLeft = 200 + padRight = 60 + barHeight = 28 + barGap = 14 + tickCount = 6 + cornerR = 0 +) + +var palette = []string{ + "#5E81AC", "#88C0D0", "#A3BE8C", "#EBCB8B", + "#D08770", "#BF616A", "#B48EAD", "#8FBCBB", +} + +func colour(i int) string { return palette[i%len(palette)] } + +func main() { + dir := resolveDir() + src := filepath.Join(dir, "results.json") + dst := filepath.Join(dir, "plot.svg") + + data, err := os.ReadFile(src) + if err != nil { + log.Fatalf("read %s: %v", src, err) + } + + var result hyperfine.Result + if err := json.Unmarshal(data, &result); err != nil { + log.Fatalf("parse: %v", err) + } + + if len(result.Results) == 0 { + log.Fatal("no benchmark results found") + } + + svg := render(result.Results, dir) + if err := os.WriteFile(dst, []byte(svg), 0o644); err != nil { + log.Fatalf("write %s: %v", dst, err) + } + fmt.Printf("plot written to %s\n", dst) + + pngPath := filepath.Join(dir, "plot.png") + + cmd := exec.Command("magick", + "-density", "192", + "-background", "none", + dst, + pngPath, + ) + + if err := cmd.Run(); err != nil { + log.Fatalf("convert to png: %v", err) + } + + fmt.Printf("png written to %s\n", pngPath) +} + +func resolveDir() string { + if len(os.Args) > 1 { + return os.Args[1] + } + return filepath.Join("results", time.Now().Format("2006-01-02")) +} + +func render(bs []hyperfine.Benchmark, date string) string { + sort.Slice(bs, func(i, j int) bool { + return bs[i].Mean < bs[j].Mean + }) + n := len(bs) + chartH := n*(barHeight+barGap) + barGap + height := padTop + chartH + padBottom + + maxMean := 0.0 + for _, b := range bs { + if b.Mean > maxMean { + maxMean = b.Mean + } + } + scale := niceMax(maxMean, tickCount) + chartW := svgW - padLeft - padRight + + var sb strings.Builder + + fmt.Fprintf(&sb, ``, svgW, height) + fmt.Fprintln(&sb) + fmt.Fprintf(&sb, ` `, svgW, height) + fmt.Fprintln(&sb) + title := fmt.Sprintf("system fetch benchmark — %s", filepath.Base(date)) + fmt.Fprintf(&sb, ` %s`, svgW/2, title) + fmt.Fprintln(&sb) + + for i := 0; i <= tickCount; i++ { + val := scale * float64(i) / float64(tickCount) + x := padLeft + int(float64(chartW)*val/scale) + yTop := padTop + yBot := padTop + chartH + fmt.Fprintf(&sb, ` `, x, yTop, x, yBot) + fmt.Fprintln(&sb) + label := fmtTime(val) + fmt.Fprintf(&sb, ` %s`, x, padTop+chartH+18, label) + fmt.Fprintln(&sb) + } + + fmt.Fprintf(&sb, ` time (s)`, padLeft+chartW/2, padTop+chartH+38) + fmt.Fprintln(&sb) + + for i, b := range bs { + y := padTop + barGap + i*(barHeight+barGap) + barW := int(float64(chartW) * b.Mean / scale) + if barW < 1 { + barW = 1 + } + col := colour(i) + + label := trimCommand(b.Command, 28) + fmt.Fprintf(&sb, ` %s`, + padLeft-8, y+barHeight-8, label) + fmt.Fprintln(&sb) + + fmt.Fprintf(&sb, ` `, + padLeft, y, barW, barHeight, cornerR, col) + fmt.Fprintln(&sb) + + fmt.Fprintf(&sb, ` %s`, + padLeft+barW+8+(int(float64(chartW)*b.Stddev/scale)), y+barHeight-8, fmtTime(b.Mean)) + fmt.Fprintln(&sb) + } + + fmt.Fprintln(&sb, ``) + return sb.String() +} + +func niceMax(max float64, ticks int) float64 { + raw := max / float64(ticks) + exp := math.Floor(math.Log10(raw)) + mag := math.Pow(10, exp) + nice := math.Ceil(raw/mag) * mag + return nice * float64(ticks) +} + +func fmtTime(s float64) string { + switch { + case s == 0: + return "0" + case s < 0.001: + return fmt.Sprintf("%.0fµs", s*1e6) + case s < 1: + return fmt.Sprintf("%.0fms", s*1e3) + default: + return fmt.Sprintf("%.2fs", s) + } +} + +func trimCommand(cmd string, max int) string { + parts := strings.Fields(cmd) + base := parts[0] + if idx := strings.LastIndexAny(base, "/\\"); idx >= 0 { + base = base[idx+1:] + } + if len(cmd) <= max { + return cmd + } + if len(base) <= max { + return base + } + return base[:max-1] + "..." +} diff --git a/flake.lock b/flake.lock new file mode 100644 index 0000000..7ca2b06 --- /dev/null +++ b/flake.lock @@ -0,0 +1,25 @@ +{ + "nodes": { + "nixpkgs": { + "locked": { + "lastModified": 1775036866, + "narHash": "sha256-ZojAnPuCdy657PbTq5V0Y+AHKhZAIwSIT2cb8UgAz/U=", + "rev": "6201e203d09599479a3b3450ed24fa81537ebc4e", + "revCount": 972949, + "type": "tarball", + "url": "https://api.flakehub.com/f/pinned/NixOS/nixpkgs/0.1.972949%2Brev-6201e203d09599479a3b3450ed24fa81537ebc4e/019d4b63-29c4-7e95-9524-45503c792ef3/source.tar.gz" + }, + "original": { + "type": "tarball", + "url": "https://flakehub.com/f/NixOS/nixpkgs/0.1" + } + }, + "root": { + "inputs": { + "nixpkgs": "nixpkgs" + } + } + }, + "root": "root", + "version": 7 +} diff --git a/flake.nix b/flake.nix new file mode 100644 index 0000000..4e1fcb1 --- /dev/null +++ b/flake.nix @@ -0,0 +1,56 @@ +{ + description = "minimal flake for go dev"; + + inputs.nixpkgs.url = "https://flakehub.com/f/NixOS/nixpkgs/0.1"; + + outputs = inputs: let + goVersion = 25; + + supportedSystems = [ + "x86_64-linux" + "aarch64-linux" + "x86_64-darwin" + "aarch64-darwin" + ]; + forEachSupportedSystem = f: + inputs.nixpkgs.lib.genAttrs supportedSystems ( + system: + f { + pkgs = import inputs.nixpkgs { + inherit system; + overlays = [inputs.self.overlays.default]; + }; + } + ); + in { + overlays.default = final: prev: { + go = final."go_1_${toString goVersion}"; + }; + + devShells = forEachSupportedSystem ( + {pkgs}: { + default = pkgs.mkShell { + packages = with pkgs; [ + go + hyperfine + cmake + imagemagick + + # okk + fastfetch + uwufetch + pfetch + microfetch + maxfetch + yafetch + bunnyfetch + tinyfetch + leaf + nitch + disfetch + ]; + }; + } + ); + }; +} diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..75d2819 --- /dev/null +++ b/go.mod @@ -0,0 +1,3 @@ +module codeberg.org/elisiei/sysbench + +go 1.25.8 diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..e69de29 diff --git a/internal/hyperfine/schema.go b/internal/hyperfine/schema.go new file mode 100644 index 0000000..9e5e452 --- /dev/null +++ b/internal/hyperfine/schema.go @@ -0,0 +1,18 @@ +package hyperfine + +type Result struct { + Results []Benchmark `json:"results"` +} + +type Benchmark struct { + Command string `json:"command"` + Mean float64 `json:"mean"` + Stddev float64 `json:"stddev"` + Median float64 `json:"median"` + User float64 `json:"user"` + System float64 `json:"system"` + Min float64 `json:"min"` + Max float64 `json:"max"` + Times []float64 `json:"times"` + Exit []int `json:"exit_codes"` +} diff --git a/results/2026-04-02/plot.png b/results/2026-04-02/plot.png new file mode 100644 index 0000000..2025515 Binary files /dev/null and b/results/2026-04-02/plot.png differ diff --git a/results/2026-04-02/plot.svg b/results/2026-04-02/plot.svg new file mode 100644 index 0000000..77c754f --- /dev/null +++ b/results/2026-04-02/plot.svg @@ -0,0 +1,64 @@ + + + system fetch benchmark — 2026-04-02 + + 0 + + 30ms + + 60ms + + 90ms + + 120ms + + 150ms + + 180ms + time (s) + tinyfetch + + 378µs + ohmyfetch + + 600µs + microfetch + + 675µs + leaf + + 723µs + unfetch + + 2ms + bunnyfetch + + 3ms + gotcha + + 4ms + novofetch + + 12ms + maxfetch + + 27ms + fastfetch + + 65ms + nitch + + 66ms + uwufetch + + 71ms + pfetch + + 106ms + disfetch + + 114ms + yafetch + + 155ms + diff --git a/results/2026-04-02/results.json b/results/2026-04-02/results.json new file mode 100644 index 0000000..45cf137 --- /dev/null +++ b/results/2026-04-02/results.json @@ -0,0 +1,694 @@ +{ + "results": [ + { + "command": "unfetch", + "mean": 0.0022385035000000004, + "stddev": 0.0003174119251163314, + "median": 0.0020978065000000004, + "user": 0.0006332999999999999, + "system": 0.0017074, + "min": 0.001882069, + "max": 0.002857402, + "times": [ + 0.002857402, + 0.002085407, + 0.002034148, + 0.002295946, + 0.002039555, + 0.001882069, + 0.002736932, + 0.0021075860000000003, + 0.002088027, + 0.002257963 + ], + "memory_usage_byte": [ + 3260416, + 3260416, + 3260416, + 3260416, + 3260416, + 3260416, + 3260416, + 3260416, + 3260416, + 3260416 + ], + "exit_codes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + { + "command": "gotcha", + "mean": 0.0035468293999999997, + "stddev": 0.000255579077324938, + "median": 0.0034554780000000005, + "user": 0.0009387999999999998, + "system": 0.0021627, + "min": 0.003261369, + "max": 0.003993994, + "times": [ + 0.003377792, + 0.0036821230000000003, + 0.003261369, + 0.003993994, + 0.0034103310000000004, + 0.0035552210000000003, + 0.0033509750000000004, + 0.003960367, + 0.0033754970000000003, + 0.0035006250000000003 + ], + "memory_usage_byte": [ + 3383296, + 3383296, + 3383296, + 3383296, + 3383296, + 3383296, + 3383296, + 3457024, + 3457024, + 3457024 + ], + "exit_codes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + { + "command": "novofetch", + "mean": 0.012202712000000001, + "stddev": 0.00063623242264408, + "median": 0.012447193000000002, + "user": 0.006195000000000001, + "system": 0.0058032, + "min": 0.010892843000000001, + "max": 0.012786427000000001, + "times": [ + 0.011586441000000001, + 0.010892843000000001, + 0.012181315000000002, + 0.012786427000000001, + 0.012445791000000001, + 0.012448595000000002, + 0.011605183000000002, + 0.012681912, + 0.01264029, + 0.012758323 + ], + "memory_usage_byte": [ + 4423680, + 4460544, + 4464640, + 4464640, + 4501504, + 4501504, + 4513792, + 4513792, + 4513792, + 4513792 + ], + "exit_codes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + { + "command": "ohmyfetch", + "mean": 0.0006002309, + "stddev": 0.0002647900221120502, + "median": 0.000508593, + "user": 0.00022719999999999997, + "system": 0.0001643, + "min": 0.00041302900000000003, + "max": 0.001325144, + "times": [ + 0.00047614500000000003, + 0.0006861170000000001, + 0.000516125, + 0.000501061, + 0.001325144, + 0.0004959060000000001, + 0.000584297, + 0.000517359, + 0.00041302900000000003, + 0.00048712600000000005 + ], + "memory_usage_byte": [ + 4513792, + 4513792, + 4513792, + 4513792, + 4513792, + 4513792, + 4513792, + 4513792, + 4513792, + 4513792 + ], + "exit_codes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + { + "command": "fastfetch", + "mean": 0.0646344437, + "stddev": 0.000934254720716171, + "median": 0.064571338, + "user": 0.0353326, + "system": 0.023932199999999997, + "min": 0.06351946800000001, + "max": 0.066359706, + "times": [ + 0.06384044500000001, + 0.066359706, + 0.064628218, + 0.065870131, + 0.06451445800000001, + 0.06373005500000001, + 0.063971232, + 0.064966497, + 0.06494422700000001, + 0.06351946800000001 + ], + "memory_usage_byte": [ + 38440960, + 38440960, + 38440960, + 38440960, + 38440960, + 38440960, + 38440960, + 38440960, + 38440960, + 38440960 + ], + "exit_codes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + { + "command": "uwufetch", + "mean": 0.0705585522, + "stddev": 0.002537658871303442, + "median": 0.0705885655, + "user": 0.03415749999999999, + "system": 0.0174794, + "min": 0.0673625, + "max": 0.074461179, + "times": [ + 0.07394387300000001, + 0.067780083, + 0.070670565, + 0.074461179, + 0.072758483, + 0.070506566, + 0.071041346, + 0.068624157, + 0.06843677000000001, + 0.0673625 + ], + "memory_usage_byte": [ + 39690240, + 39690240, + 39690240, + 39690240, + 39690240, + 39690240, + 39690240, + 39718912, + 39718912, + 39718912 + ], + "exit_codes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + { + "command": "pfetch", + "mean": 0.10646233320000001, + "stddev": 0.0023372693386104234, + "median": 0.10591897050000001, + "user": 0.057895600000000005, + "system": 0.027185699999999997, + "min": 0.10361937, + "max": 0.11059798800000001, + "times": [ + 0.10680668500000001, + 0.11059798800000001, + 0.10442108100000001, + 0.10361937, + 0.10648627100000001, + 0.10535167000000001, + 0.104607878, + 0.108106827, + 0.10964409500000001, + 0.10498146700000001 + ], + "memory_usage_byte": [ + 39718912, + 39718912, + 39718912, + 39718912, + 39718912, + 39718912, + 39718912, + 39718912, + 39718912, + 39718912 + ], + "exit_codes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + { + "command": "microfetch", + "mean": 0.0006745818000000001, + "stddev": 0.00019510672639683362, + "median": 0.0006067715, + "user": 0.0002762, + "system": 0.0002441, + "min": 0.000521223, + "max": 0.001192038, + "times": [ + 0.0005620050000000001, + 0.001192038, + 0.000683786, + 0.0005954850000000001, + 0.000618058, + 0.000648624, + 0.000521223, + 0.0005696140000000001, + 0.000584215, + 0.00077077 + ], + "memory_usage_byte": [ + 39718912, + 39718912, + 39718912, + 39718912, + 39718912, + 39718912, + 39718912, + 39718912, + 39718912, + 39718912 + ], + "exit_codes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + { + "command": "maxfetch", + "mean": 0.027357907900000006, + "stddev": 0.0006798183197001078, + "median": 0.0270602775, + "user": 0.0144233, + "system": 0.013652099999999997, + "min": 0.026603717000000002, + "max": 0.028590595000000003, + "times": [ + 0.028590595000000003, + 0.026964999000000003, + 0.026980317, + 0.026603717000000002, + 0.027305160000000002, + 0.027038212000000002, + 0.027939273, + 0.028308879000000002, + 0.027082343000000002, + 0.026765584000000002 + ], + "memory_usage_byte": [ + 39718912, + 39718912, + 39718912, + 39718912, + 39718912, + 39718912, + 39718912, + 39718912, + 39718912, + 39718912 + ], + "exit_codes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + { + "command": "yafetch", + "mean": 0.15481940830000002, + "stddev": 0.006181885642413707, + "median": 0.1527790785, + "user": 0.06248459999999999, + "system": 0.024116199999999997, + "min": 0.148908501, + "max": 0.167369285, + "times": [ + 0.149389735, + 0.148908501, + 0.15471316200000002, + 0.151076881, + 0.167369285, + 0.152391721, + 0.16448885800000002, + 0.152695108, + 0.152863049, + 0.15429778300000002 + ], + "memory_usage_byte": [ + 43085824, + 43085824, + 43085824, + 43085824, + 43180032, + 43180032, + 43180032, + 43225088, + 43225088, + 43225088 + ], + "exit_codes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + { + "command": "bunnyfetch", + "mean": 0.0028225839000000003, + "stddev": 0.00039742990606379613, + "median": 0.0027287055000000003, + "user": 0.0013399000000000002, + "system": 0.0013215999999999998, + "min": 0.002408003, + "max": 0.0036136320000000003, + "times": [ + 0.002789868, + 0.002616792, + 0.002751269, + 0.00244452, + 0.003420831, + 0.0027061420000000004, + 0.0025848990000000003, + 0.002889883, + 0.002408003, + 0.0036136320000000003 + ], + "memory_usage_byte": [ + 43225088, + 43225088, + 43225088, + 43225088, + 43225088, + 43225088, + 43225088, + 43225088, + 43225088, + 43225088 + ], + "exit_codes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + { + "command": "tinyfetch", + "mean": 0.0003782007, + "stddev": 0.00001775450322250042, + "median": 0.00037456100000000003, + "user": 0.0002456, + "system": 0.00005819999999999999, + "min": 0.00036095, + "max": 0.000419438, + "times": [ + 0.000374346, + 0.000397187, + 0.000419438, + 0.000376263, + 0.000369038, + 0.00038001200000000005, + 0.00036095, + 0.000367473, + 0.000374776, + 0.00036252400000000003 + ], + "memory_usage_byte": [ + 43225088, + 43225088, + 43225088, + 43225088, + 43225088, + 43225088, + 43225088, + 43225088, + 43225088, + 43225088 + ], + "exit_codes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + { + "command": "leaf", + "mean": 0.0007234522000000001, + "stddev": 0.0002504221609344242, + "median": 0.0006351105000000001, + "user": 0.0003683, + "system": 0.0001606, + "min": 0.000588737, + "max": 0.001427307, + "times": [ + 0.0007024370000000001, + 0.000612083, + 0.0006214930000000001, + 0.000686148, + 0.0006224070000000001, + 0.000588737, + 0.000635508, + 0.001427307, + 0.0007036890000000001, + 0.0006347130000000001 + ], + "memory_usage_byte": [ + 43225088, + 43225088, + 43225088, + 43225088, + 43225088, + 43225088, + 43225088, + 43225088, + 43225088, + 43225088 + ], + "exit_codes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + { + "command": "nitch", + "mean": 0.0659787543, + "stddev": 0.0019520452025518738, + "median": 0.066265235, + "user": 0.030220099999999993, + "system": 0.0125106, + "min": 0.06247603, + "max": 0.06896249, + "times": [ + 0.06569058900000001, + 0.064645756, + 0.065933382, + 0.067046559, + 0.063613101, + 0.06247603, + 0.066597088, + 0.067548207, + 0.06896249, + 0.067274341 + ], + "memory_usage_byte": [ + 43225088, + 43225088, + 43225088, + 43225088, + 43225088, + 43225088, + 43225088, + 43225088, + 43225088, + 43225088 + ], + "exit_codes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + { + "command": "disfetch", + "mean": 0.11399507830000002, + "stddev": 0.0009120492128381454, + "median": 0.11396585000000001, + "user": 0.0827763, + "system": 0.039833099999999996, + "min": 0.11247182800000001, + "max": 0.115289259, + "times": [ + 0.11483957800000001, + 0.11406091700000001, + 0.11439436300000001, + 0.11504565100000001, + 0.113293158, + 0.113870783, + 0.113067736, + 0.11247182800000001, + 0.11361751, + 0.115289259 + ], + "memory_usage_byte": [ + 43225088, + 43225088, + 43225088, + 43225088, + 43225088, + 43225088, + 43225088, + 43225088, + 43225088, + 43225088 + ], + "exit_codes": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + ] +} diff --git a/results/2026-04-02/results.md b/results/2026-04-02/results.md new file mode 100644 index 0000000..b9850a6 --- /dev/null +++ b/results/2026-04-02/results.md @@ -0,0 +1,17 @@ +| Command | Mean [ms] | Min [ms] | Max [ms] | Relative | +|:---|---:|---:|---:|---:| +| `tinyfetch` | 0.4 ± 0.0 | 0.4 | 0.4 | 1.00 | +| `ohmyfetch` | 0.6 ± 0.3 | 0.4 | 1.3 | 1.59 ± 0.70 | +| `microfetch` | 0.7 ± 0.2 | 0.5 | 1.2 | 1.78 ± 0.52 | +| `leaf` | 0.7 ± 0.3 | 0.6 | 1.4 | 1.91 ± 0.67 | +| `unfetch` | 2.2 ± 0.3 | 1.9 | 2.9 | 5.92 ± 0.88 | +| `bunnyfetch` | 2.8 ± 0.4 | 2.4 | 3.6 | 7.46 ± 1.11 | +| `gotcha` | 3.5 ± 0.3 | 3.3 | 4.0 | 9.38 ± 0.81 | +| `novofetch` | 12.2 ± 0.6 | 10.9 | 12.8 | 32.27 ± 2.26 | +| `maxfetch` | 27.4 ± 0.7 | 26.6 | 28.6 | 72.34 ± 3.84 | +| `fastfetch` | 64.6 ± 0.9 | 63.5 | 66.4 | 170.90 ± 8.39 | +| `nitch` | 66.0 ± 2.0 | 62.5 | 69.0 | 174.45 ± 9.68 | +| `uwufetch` | 70.6 ± 2.5 | 67.4 | 74.5 | 186.56 ± 11.03 | +| `pfetch` | 106.5 ± 2.3 | 103.6 | 110.6 | 281.50 ± 14.59 | +| `disfetch` | 114.0 ± 0.9 | 112.5 | 115.3 | 301.41 ± 14.35 | +| `yafetch` | 154.8 ± 6.2 | 148.9 | 167.4 | 409.36 ± 25.23 |