Use cargo_bin! to locate the integration test binary

.github/workflows/CICD.yml

@@ -79,7 +79,6 @@ jobs:
       matrix:
         job:
           - { target: aarch64-unknown-linux-gnu   , os: ubuntu-24.04, use-cross: true }
-          - { target: aarch64-unknown-linux-musl  , os: ubuntu-24.04, use-cross: true }
           - { target: arm-unknown-linux-gnueabihf , os: ubuntu-24.04, use-cross: true }
           - { target: arm-unknown-linux-musleabihf, os: ubuntu-24.04, use-cross: true }
           - { target: i686-pc-windows-msvc        , os: windows-2022                  }

CITATION.cff

@@ -13,5 +13,5 @@ authors:
 repository-code: 'https://github.com/sharkdp/hyperfine'
 abstract: A command-line benchmarking tool.
 license: MIT
-version: 1.20.0
-date-released: '2025-11-18'
+version: 1.16.1
+date-released: '2023-03-21'

Cargo.toml

@@ -10,23 +10,22 @@ repository = "https://github.com/sharkdp/hyperfine"
 version = "1.20.0"
 edition = "2018"
 build = "build.rs"
-rust-version = "1.97.0"
+rust-version = "1.88.0"
 
 [features]
 # Use the nightly feature windows_process_extensions_main_thread_handle
 windows_process_extensions_main_thread_handle = []
 
 [dependencies]
-colored = "3.1"
-# Newer versions regress ETA estimates: https://github.com/console-rs/indicatif/issues/580
+colored = "2.1"
 indicatif = "=0.17.4"
 statistical = "1.0"
-csv = "1.4"
+csv = "1.3"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
-rust_decimal = "1.43"
-rand = "0.10"
-shell-words = "1.1"
+rust_decimal = "1.36"
+rand = "0.8"
+shell-words = "1.0"
 thiserror = "2.0"
 anyhow = "1.0"
 
@@ -34,7 +33,7 @@ anyhow = "1.0"
 libc = "0.2"
 
 [target.'cfg(windows)'.dependencies]
-windows-sys = { version = "0.61", features = [
+windows-sys = { version = "0.59", features = [
     "Win32_Foundation",
     "Win32_Security",
     "Win32_System_JobObjects",
@@ -43,10 +42,10 @@ windows-sys = { version = "0.61", features = [
 ] }
 
 [target.'cfg(all(windows, not(windows_process_extensions_main_thread_handle)))'.dependencies]
-once_cell = "1.21"
+once_cell = "1.19"
 
 [target.'cfg(target_os="linux")'.dependencies]
-nix = { version = "0.31", features = ["zerocopy"] }
+nix = { version = "0.29", features = ["zerocopy"] }
 
 [dependencies.clap]
 version = "4"
@@ -63,18 +62,18 @@ features = [
 
 [dev-dependencies]
 approx = "0.5"
-assert_cmd = "2.2"
-insta = { version = "1.48", features = ["yaml"] }
+assert_cmd = "2.0"
+insta = { version = "1.41.1", features = ["yaml"] }
 predicates = "3.1"
-tempfile = "3.27"
+tempfile = "3.23"
 
 [profile.dev.package]
 insta.opt-level = 3
 similar.opt-level = 3
 
 [build-dependencies]
-clap = "4.6"
-clap_complete = "4.6"
+clap = "4.5.48"
+clap_complete = "4.2.1"
 
 [profile.release]
 lto = true

README.md

@@ -108,7 +108,7 @@ hyperfine -N 'grep TODO /home/user'
 ```
 
 
-### Shell functions
+### Shell functions and aliases
 
 If you are using bash, you can export shell functions to directly benchmark them with hyperfine:
 
@@ -118,10 +118,13 @@ export -f my_function
 hyperfine --shell=bash my_function
 ```
 
-Otherwise, inline the function into the benchmarked command:
+Otherwise, inline them into or source them from the benchmarked program:
 
 ```sh
 hyperfine 'my_function() { sleep 1; }; my_function'
+
+echo 'alias my_alias="sleep 1"' > /tmp/my_alias.sh
+hyperfine '. /tmp/my_alias.sh; my_alias'
 ```
 
 ### Exporting results
@@ -302,7 +305,7 @@ Hyperfine can be installed from source via [cargo](https://doc.rust-lang.org/car
 cargo install --locked hyperfine
 ```
 
-Make sure that you use Rust 1.97 or newer.
+Make sure that you use Rust 1.76 or newer.
 
 ### From binaries (Linux, macOS, Windows)
 

scripts/README.md

@@ -4,14 +4,23 @@ This folder contains scripts that can be used in combination with hyperfines `--
 
 ```bash
 hyperfine 'sleep 0.020' 'sleep 0.021' 'sleep 0.022' --export-json sleep.json
-uv run plot_whisker.py sleep.json
+./plot_whisker.py sleep.json
 ```
 
 ### Pre-requisites
 
-Install [`uv`](https://docs.astral.sh/uv/getting-started/installation/) and run the
-commands above from this directory.
+To make these scripts work, you will need `numpy`, `matplotlib` and `scipy`.
 
-The scripts declare their dependencies using [PEP 723](https://peps.python.org/pep-0723/)
-inline script metadata. `uv run` automatically installs these dependencies in an
-isolated environment before running the script.
+If you have a Python package manager that understands [PEP-723](https://peps.python.org/pep-0723/)
+inline script requirements like [`uv`](https://github.com/astral-sh/uv) or [`pipx`](https://github.com/pypa/pipx),
+you can directly run the scripts using
+
+```bash
+uv run plot_whisker.py sleep.json
+```
+
+Otherwise, install the dependencies via your system package manager or using `pip`:
+
+```bash
+pip install numpy matplotlib scipy  # pip3, if you are using python3
+```

src/benchmark/mod.rs

@@ -5,7 +5,6 @@ pub mod scheduler;
 pub mod timing_result;
 
 use std::cmp;
-use std::io::{self, Write};
 
 use crate::benchmark::executor::BenchmarkIteration;
 use crate::command::Command;
@@ -13,7 +12,6 @@ use crate::options::{
     CmdFailureAction, CommandOutputPolicy, ExecutorKind, Options, OutputStyleOption,
 };
 use crate::outlier_detection::{modified_zscores, OUTLIER_THRESHOLD};
-use crate::output::console_writeln;
 use crate::output::format::{format_duration, format_duration_unit};
 use crate::output::progress_bar::get_progress_bar;
 use crate::output::warnings::{OutlierWarningOptions, Warnings};
@@ -142,13 +140,12 @@ impl<'a> Benchmark<'a> {
     /// Run the benchmark for a single command
     pub fn run(&self) -> Result<BenchmarkResult> {
         if self.options.output_style != OutputStyleOption::Disabled {
-            console_writeln!(
-                io::stdout(),
+            println!(
                 "{}{}: {}",
                 "Benchmark ".bold(),
                 (self.number + 1).to_string().bold(),
                 self.command.get_name_with_unused_parameters(),
-            )?;
+            );
         }
 
         let mut times_real: Vec<Second> = vec![];
@@ -361,22 +358,19 @@ impl<'a> Benchmark<'a> {
         let system_str = format_duration(system_mean, Some(time_unit));
 
         if self.options.output_style != OutputStyleOption::Disabled {
-            let mut stdout = io::stdout().lock();
             if times_real.len() == 1 {
-                console_writeln!(
-                    stdout,
+                println!(
                     "  Time ({} ≡):        {:>8}  {:>8}     [User: {}, System: {}]",
                     "abs".green().bold(),
                     mean_str.green().bold(),
                     "        ", // alignment
                     user_str.blue(),
                     system_str.blue()
-                )?;
+                );
             } else {
                 let stddev_str = format_duration(t_stddev.unwrap(), Some(time_unit));
 
-                console_writeln!(
-                    stdout,
+                println!(
                     "  Time ({} ± {}):     {:>8} ± {:>8}    [User: {}, System: {}]",
                     "mean".green().bold(),
                     "σ".green(),
@@ -384,17 +378,16 @@ impl<'a> Benchmark<'a> {
                     stddev_str.green(),
                     user_str.blue(),
                     system_str.blue()
-                )?;
+                );
 
-                console_writeln!(
-                    stdout,
+                println!(
                     "  Range ({} … {}):   {:>8} … {:>8}    {}",
                     "min".cyan(),
                     "max".purple(),
                     min_str.cyan(),
                     max_str.purple(),
                     num_str.dimmed()
-                )?;
+                );
             }
         }
 
@@ -437,16 +430,15 @@ impl<'a> Benchmark<'a> {
         }
 
         if !warnings.is_empty() {
-            let mut stderr = io::stderr().lock();
-            console_writeln!(stderr, " ")?;
+            eprintln!(" ");
 
             for warning in &warnings {
-                console_writeln!(stderr, "  {}: {}", "Warning".yellow(), warning)?;
+                eprintln!("  {}: {}", "Warning".yellow(), warning);
             }
         }
 
         if self.options.output_style != OutputStyleOption::Disabled {
-            console_writeln!(io::stdout(), " ")?;
+            println!(" ");
         }
 
         self.run_cleanup_command(self.command.get_parameters().iter().cloned(), output_policy)?;

src/benchmark/scheduler.rs

@@ -3,12 +3,10 @@ use super::executor::{Executor, MockExecutor, RawExecutor, ShellExecutor};
 use super::{relative_speed, Benchmark};
 use colored::*;
 use std::cmp::Ordering;
-use std::io::{self, Write};
 
 use crate::command::{Command, Commands};
 use crate::export::ExportManager;
 use crate::options::{ExecutorKind, Options, OutputStyleOption, SortOrder};
-use crate::output::console_writeln;
 
 use anyhow::Result;
 
@@ -60,13 +58,13 @@ impl<'a> Scheduler<'a> {
         Ok(())
     }
 
-    pub fn print_relative_speed_comparison(&self) -> Result<()> {
+    pub fn print_relative_speed_comparison(&self) {
         if self.options.output_style == OutputStyleOption::Disabled {
-            return Ok(());
+            return;
         }
 
         if self.results.len() < 2 {
-            return Ok(());
+            return;
         }
 
         let reference = self
@@ -81,19 +79,17 @@ impl<'a> Scheduler<'a> {
             reference,
             self.options.sort_order_speed_comparison,
         ) {
-            let mut stdout = io::stdout().lock();
             match self.options.sort_order_speed_comparison {
                 SortOrder::MeanTime => {
-                    console_writeln!(stdout, "{}", "Summary".bold())?;
+                    println!("{}", "Summary".bold());
 
                     let reference = annotated_results.iter().find(|r| r.is_reference).unwrap();
                     let others = annotated_results.iter().filter(|r| !r.is_reference);
 
-                    console_writeln!(
-                        stdout,
+                    println!(
                         "  {} ran",
                         reference.result.command_with_unused_parameters.cyan()
-                    )?;
+                    );
 
                     for item in others {
                         let stddev = if let Some(stddev) = item.relative_speed_stddev {
@@ -118,20 +114,18 @@ impl<'a> Scheduler<'a> {
                                 stddev
                             ),
                         };
-                        console_writeln!(
-                            stdout,
+                        println!(
                             "{} {}",
                             comparator,
-                            item.result.command_with_unused_parameters.magenta()
-                        )?;
+                            &item.result.command_with_unused_parameters.magenta()
+                        );
                     }
                 }
                 SortOrder::Command => {
-                    console_writeln!(stdout, "{}", "Relative speed comparison".bold())?;
+                    println!("{}", "Relative speed comparison".bold());
 
                     for item in annotated_results {
-                        console_writeln!(
-                            stdout,
+                        println!(
                             "  {}{}  {}",
                             format!("{:10.2}", item.relative_speed).bold().green(),
                             if item.is_reference {
@@ -141,14 +135,13 @@ impl<'a> Scheduler<'a> {
                             } else {
                                 "        ".into()
                             },
-                            item.result.command_with_unused_parameters,
-                        )?;
+                            &item.result.command_with_unused_parameters,
+                        );
                     }
                 }
             }
         } else {
-            console_writeln!(
-                io::stderr(),
+            eprintln!(
                 "{}: The benchmark comparison could not be computed as some benchmark times are zero. \
                  This could be caused by background interference during the initial calibration phase \
                  of hyperfine, in combination with very fast commands (faster than a few milliseconds). \
@@ -156,10 +149,8 @@ impl<'a> Scheduler<'a> {
                  --shell=none/-N option. If it does not help either, you command is most likely too fast \
                  to be accurately benchmarked by hyperfine.",
                  "Note".bold().red()
-            )?;
+            );
         }
-
-        Ok(())
     }
 
     pub fn final_export(&self) -> Result<()> {

src/command.rs

@@ -158,9 +158,7 @@ impl<'a> Commands<'a> {
             });
             let args: Vec<_> = args.map(|v| v.as_str()).collect::<Vec<_>>();
             let param_names_and_values: Vec<(&str, Vec<String>)> = args
-                .as_chunks::<2>()
-                .0
-                .iter()
+                .chunks_exact(2)
                 .map(|pair| {
                     let name = pair[0];
                     let list_str = pair[1];
@@ -171,7 +169,7 @@ impl<'a> Commands<'a> {
                 let duplicates =
                     Self::find_duplicates(param_names_and_values.iter().map(|(name, _)| *name));
                 if !duplicates.is_empty() {
-                    bail!("Duplicate parameter names: {}", duplicates.join(", "));
+                    bail!("Duplicate parameter names: {}", &duplicates.join(", "));
                 }
             }
 

src/error.rs

@@ -3,10 +3,6 @@ use std::num::{self, ParseFloatError, ParseIntError};
 use rust_decimal::Error as DecimalError;
 use thiserror::Error;
 
-#[derive(Debug, Error)]
-#[error(transparent)]
-pub struct ConsoleOutputError(pub std::io::Error);
-
 #[derive(Debug, Error)]
 pub enum ParameterScanError {
     #[error("Error while parsing parameter scan arguments ({0})")]

src/export/mod.rs

@@ -1,5 +1,5 @@
 use std::fs::{File, OpenOptions};
-use std::io::{self, Write};
+use std::io::Write;
 
 mod asciidoc;
 mod csv;
@@ -18,7 +18,6 @@ use self::orgmode::OrgmodeExporter;
 
 use crate::benchmark::benchmark_result::BenchmarkResult;
 use crate::options::SortOrder;
-use crate::output::console_writeln;
 use crate::util::units::Unit;
 
 use anyhow::{Context, Result};
@@ -145,9 +144,8 @@ impl ExportManager {
                 }
                 ExportTarget::Stdout => {
                     if !intermediate {
-                        let mut stdout = io::stdout().lock();
-                        console_writeln!(stdout)?;
-                        console_writeln!(stdout, "{}", String::from_utf8(content()?).unwrap())?;
+                        println!();
+                        println!("{}", String::from_utf8(content()?).unwrap());
                     }
                 }
             }

src/export/orgmode.rs

@@ -9,7 +9,7 @@ impl MarkupExporter for OrgmodeExporter {
         format!(
             "| {}  |  {} |\n",
             cells.first().unwrap(),
-            cells[1..].join(" |  ")
+            &cells[1..].join(" |  ")
         )
     }
 

src/main.rs

@@ -4,12 +4,10 @@
 )]
 
 use std::env;
-use std::io::{self, Write};
 
 use benchmark::scheduler::Scheduler;
 use cli::get_cli_arguments;
 use command::Commands;
-use error::ConsoleOutputError;
 use export::ExportManager;
 use options::Options;
 
@@ -46,29 +44,17 @@ fn run() -> Result<()> {
 
     let mut scheduler = Scheduler::new(&commands, &options, &export_manager);
     scheduler.run_benchmarks()?;
-    scheduler.print_relative_speed_comparison()?;
+    scheduler.print_relative_speed_comparison();
     scheduler.final_export()?;
 
     Ok(())
 }
 
-fn caused_by_broken_console_pipe(error: &anyhow::Error) -> bool {
-    error
-        .downcast_ref::<ConsoleOutputError>()
-        .is_some_and(|e| e.0.kind() == io::ErrorKind::BrokenPipe)
-}
-
 fn main() {
     match run() {
         Ok(_) => {}
         Err(e) => {
-            // Exit quietly when a reader stops consuming console output early.
-            if caused_by_broken_console_pipe(&e) {
-                std::process::exit(0);
-            }
-            // The write to stderr can itself fail if stderr is closed; the
-            // error message cannot be shown in that case anyway.
-            let _ = writeln!(io::stderr(), "{} {:#}", "Error:".red(), e);
+            eprintln!("{} {:#}", "Error:".red(), e);
             std::process::exit(1);
         }
     }

src/output/mod.rs

@@ -1,13 +1,3 @@
 pub mod format;
 pub mod progress_bar;
 pub mod warnings;
-
-/// Mark console write errors so broken pipes can be handled separately from file errors.
-macro_rules! console_writeln {
-    ($writer:expr $(, $($args:tt)*)?) => {
-        writeln!($writer $(, $($args)*)?)
-            .map_err($crate::error::ConsoleOutputError)
-    };
-}
-
-pub(crate) use console_writeln;

src/util/randomized_environment_offset.rs

@@ -4,5 +4,5 @@
 /// [1] Mytkowicz, 2009. Producing Wrong Data Without Doing Anything Obviously Wrong!.
 ///     Sigplan Notices - SIGPLAN. 44. 265-276. 10.1145/1508284.1508275.
 pub fn value() -> String {
-    "X".repeat(rand::random_range(0..4096))
+    "X".repeat(rand::random::<usize>() % 4096usize)
 }

tests/integration_tests.rs

@@ -1,5 +1,5 @@
 mod common;
-use common::{hyperfine, hyperfine_raw_command};
+use common::hyperfine;
 
 use predicates::prelude::*;
 
@@ -33,47 +33,6 @@ fn one_run_is_supported() {
         .success();
 }
 
-/// Regression test: hyperfine must not panic when writing to a closed
-/// stdout pipe (e.g. `hyperfine ... | head -n 1` or a downstream process
-/// that terminates early). A `BrokenPipe` error should result in a quiet
-/// exit with code 0 instead of a `println!` panic.
-#[test]
-fn exits_quietly_when_stdout_is_closed() {
-    use std::process::Stdio;
-
-    for args in [
-        vec!["--runs=1", "echo dummy benchmark"],
-        vec!["--runs=1", "--export-json=-", "echo dummy benchmark"],
-        vec!["--runs=1", "echo dummy benchmark", "echo second benchmark"],
-    ] {
-        // A pipe whose read end has been closed before hyperfine is even
-        // started: every write to it will fail with `BrokenPipe`.
-        let (reader, writer) = std::io::pipe().expect("failed to create pipe");
-        drop(reader);
-
-        let output = hyperfine_raw_command()
-            .args(&args)
-            .stdout(writer)
-            .stderr(Stdio::piped())
-            .spawn()
-            .expect("failed to spawn hyperfine")
-            .wait_with_output()
-            .expect("failed to wait for hyperfine");
-        let stderr = String::from_utf8_lossy(&output.stderr);
-
-        assert!(
-            !stderr.contains("panicked"),
-            "hyperfine panicked while writing to a closed pipe:\n{}",
-            stderr
-        );
-        assert!(
-            output.status.success(),
-            "hyperfine did not exit cleanly; stderr:\n{}",
-            stderr
-        );
-    }
-}
-
 #[test]
 fn can_run_commands_without_a_shell() {
     hyperfine()