From 60b5303ce6551c57d910ee38ae35afa14a43eb60 Mon Sep 17 00:00:00 2001
From: Alex Atkinson <alex@evilkittens.co>
Date: Sat, 28 Feb 2026 19:30:41 -0500
Subject: [PATCH 1/4] feat: Add TZ Abbreviations

---
 src/output/time.rs | 71 ++++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 66 insertions(+), 5 deletions(-)

diff --git a/src/output/time.rs b/src/output/time.rs
index f003745b0..b52ce2801 100644
--- a/src/output/time.rs
+++ b/src/output/time.rs
@@ -126,21 +126,82 @@ fn relative(time: &DateTime<FixedOffset>) -> String {
 }
 
 fn full(time: &DateTime<FixedOffset>) -> String {
-    time.format("%Y-%m-%d %H:%M:%S.%f %z").to_string()
+    format_with_tz(time, "%Y-%m-%d %H:%M:%S.%f %z")
 }
 
 fn custom(time: &DateTime<FixedOffset>, non_recent_fmt: &str, recent_fmt: Option<&str>) -> String {
-    if let Some(recent_fmt) = recent_fmt {
+    let format = if let Some(recent_fmt) = recent_fmt {
         if time.year() == *CURRENT_YEAR {
-            time.format(recent_fmt).to_string()
+            recent_fmt
         } else {
-            time.format(non_recent_fmt).to_string()
+            non_recent_fmt
         }
     } else {
-        time.format(non_recent_fmt).to_string()
+        non_recent_fmt
+    };
+
+    format_with_tz(time, format)
+}
+
+fn format_with_tz(time: &DateTime<FixedOffset>, format: &str) -> String {
+    if !format.contains("%Z") {
+        return time.format(format).to_string();
+    }
+
+    let tz_name = TZ_HANDLER.get_abbreviation(time.timestamp());
+    let mut result = String::new();
+    let mut last_end = 0;
+    for (start, part) in format.match_indices("%Z") {
+        result.push_str(&time.format(&format[last_end..start]).to_string());
+        result.push_str(&tz_name);
+        last_end = start + part.len();
+    }
+    result.push_str(&time.format(&format[last_end..]).to_string());
+    result
+}
+
+struct TimezoneHandler;
+
+impl TimezoneHandler {
+    fn get_abbreviation(&self, timestamp: i64) -> String {
+        #[cfg(unix)]
+        {
+            unsafe {
+                extern "C" {
+                    fn tzset();
+                    fn localtime_r(
+                        timep: *const libc::time_t,
+                        result: *mut libc::tm,
+                    ) -> *mut libc::tm;
+                    static tzname: [*const libc::c_char; 2];
+                }
+
+                tzset();
+                let mut tm: libc::tm = std::mem::zeroed();
+                #[allow(trivial_numeric_casts)]
+                let t = timestamp as libc::time_t;
+                if localtime_r(&t, &mut tm).is_null() {
+                    return String::new();
+                }
+
+                let idx = if tm.tm_isdst > 0 { 1 } else { 0 };
+                let ptr = tzname[idx];
+                if ptr.is_null() {
+                    return String::new();
+                }
+
+                std::ffi::CStr::from_ptr(ptr).to_string_lossy().into_owned()
+            }
+        }
+        #[cfg(not(unix))]
+        {
+            String::new()
+        }
     }
 }
 
+static TZ_HANDLER: LazyLock<TimezoneHandler> = LazyLock::new(|| TimezoneHandler);
+
 static CURRENT_YEAR: LazyLock<i32> = LazyLock::new(|| Local::now().year());
 
 static LOCALE: LazyLock<locale::Time> =

From a058861cd5cd731d289589230cf866518e047374 Mon Sep 17 00:00:00 2001
From: Alex Atkinson <alex@evilkittens.co>
Date: Sat, 28 Feb 2026 19:37:14 -0500
Subject: [PATCH 2/4] feat: Add UTC argument

---
 src/options/parser.rs      |  1 +
 src/options/view.rs        |  2 ++
 src/output/render/times.rs | 24 ++++++++++++++++++------
 src/output/table.rs        | 10 +++++++++-
 src/output/time.rs         | 27 ++++++++++++++++++---------
 5 files changed, 48 insertions(+), 16 deletions(-)

diff --git a/src/options/parser.rs b/src/options/parser.rs
index c5b592fc7..43d88b825 100644
--- a/src/options/parser.rs
+++ b/src/options/parser.rs
@@ -132,6 +132,7 @@ pub fn get_command() -> clap::Command {
         .arg(arg!(-u --accessed "show the accessed timestamp field (replace default field, combinable)"))
         .arg(arg!(--changed "show the changed timestamp field (replace default field, combinable)"))
         .arg(arg!(-U --created "show the created timestamp field (replace default field, combinable)"))
+        .arg(arg!(--utc "show the time in the UTC timezone"))
         .arg(arg!(--"time-style" <STYLE>)
             .help(format!("how to format timestamps {FORMAT_STYLE_FIELDS_HELP}"))
             .value_parser(TimeFormatParser)
diff --git a/src/options/view.rs b/src/options/view.rs
index 922f193cf..033eb2448 100644
--- a/src/options/view.rs
+++ b/src/options/view.rs
@@ -240,6 +240,7 @@ impl TableOptions {
         let user_format = UserFormat::deduce(matches);
         let group_format = GroupFormat::deduce(matches);
         let columns = Columns::deduce(matches, vars)?;
+        let use_utc = matches.get_flag("utc");
         Ok(Self {
             size_format,
             time_format,
@@ -247,6 +248,7 @@ impl TableOptions {
             group_format,
             flags_format,
             columns,
+            use_utc,
         })
     }
 }
diff --git a/src/output/render/times.rs b/src/output/render/times.rs
index 88b7c1efb..ba7b76b03 100644
--- a/src/output/render/times.rs
+++ b/src/output/render/times.rs
@@ -11,16 +11,28 @@ use chrono::prelude::*;
 use nu_ansi_term::Style;
 
 pub trait Render {
-    fn render(self, style: Style, time_offset: FixedOffset, time_format: TimeFormat) -> TextCell;
+    fn render(
+        self,
+        style: Style,
+        time_offset: FixedOffset,
+        time_format: TimeFormat,
+        use_utc: bool,
+    ) -> TextCell;
 }
 
 impl Render for Option<NaiveDateTime> {
-    fn render(self, style: Style, time_offset: FixedOffset, time_format: TimeFormat) -> TextCell {
+    fn render(
+        self,
+        style: Style,
+        time_offset: FixedOffset,
+        time_format: TimeFormat,
+        use_utc: bool,
+    ) -> TextCell {
         let datestamp = if let Some(time) = self {
-            time_format.format(&DateTime::<FixedOffset>::from_naive_utc_and_offset(
-                time,
-                time_offset,
-            ))
+            time_format.format(
+                &DateTime::<FixedOffset>::from_naive_utc_and_offset(time, time_offset),
+                use_utc,
+            )
         } else {
             String::from("-")
         };
diff --git a/src/output/table.rs b/src/output/table.rs
index 3daa47257..c6dd23a66 100644
--- a/src/output/table.rs
+++ b/src/output/table.rs
@@ -39,6 +39,7 @@ pub struct Options {
     pub group_format: GroupFormat,
     pub flags_format: FlagsFormat,
     pub columns: Columns,
+    pub use_utc: bool,
 }
 
 /// Extra columns to display in the table.
@@ -417,6 +418,7 @@ pub struct Table<'a> {
     group_format: GroupFormat,
     flags_format: FlagsFormat,
     git: Option<&'a GitCache>,
+    use_utc: bool,
 }
 
 #[derive(Clone)]
@@ -451,6 +453,7 @@ impl<'a> Table<'a> {
             #[cfg(unix)]
             group_format: options.group_format,
             flags_format: options.flags_format,
+            use_utc: options.use_utc,
         }
     }
 
@@ -575,8 +578,13 @@ impl<'a> Table<'a> {
                 } else {
                     self.theme.ui.date.unwrap_or_default()
                 },
-                self.env.time_offset,
+                if self.use_utc {
+                    FixedOffset::east_opt(0).unwrap()
+                } else {
+                    self.env.time_offset
+                },
                 self.time_format.clone(),
+                self.use_utc,
             ),
         }
     }
diff --git a/src/output/time.rs b/src/output/time.rs
index b52ce2801..fb89e229e 100644
--- a/src/output/time.rs
+++ b/src/output/time.rs
@@ -63,16 +63,16 @@ pub enum TimeFormat {
 
 impl TimeFormat {
     #[must_use]
-    pub fn format(self, time: &DateTime<FixedOffset>) -> String {
+    pub fn format(self, time: &DateTime<FixedOffset>, use_utc: bool) -> String {
         #[rustfmt::skip]
         return match self {
             Self::DefaultFormat                 => default(time),
             Self::ISOFormat                     => iso(time),
             Self::LongISO                       => long(time),
-            Self::FullISO                       => full(time),
+            Self::FullISO                       => full(time, use_utc),
             Self::Relative                      => relative(time),
             Self::Custom { non_recent, recent } => custom(
-                time, non_recent.as_str(), recent.as_deref()
+                time, non_recent.as_str(), recent.as_deref(), use_utc
             ),
         };
     }
@@ -125,11 +125,16 @@ fn relative(time: &DateTime<FixedOffset>) -> String {
         ))
 }
 
-fn full(time: &DateTime<FixedOffset>) -> String {
-    format_with_tz(time, "%Y-%m-%d %H:%M:%S.%f %z")
+fn full(time: &DateTime<FixedOffset>, use_utc: bool) -> String {
+    format_with_tz(time, "%Y-%m-%d %H:%M:%S.%f %z", use_utc)
 }
 
-fn custom(time: &DateTime<FixedOffset>, non_recent_fmt: &str, recent_fmt: Option<&str>) -> String {
+fn custom(
+    time: &DateTime<FixedOffset>,
+    non_recent_fmt: &str,
+    recent_fmt: Option<&str>,
+    use_utc: bool,
+) -> String {
     let format = if let Some(recent_fmt) = recent_fmt {
         if time.year() == *CURRENT_YEAR {
             recent_fmt
@@ -140,15 +145,19 @@ fn custom(time: &DateTime<FixedOffset>, non_recent_fmt: &str, recent_fmt: Option
         non_recent_fmt
     };
 
-    format_with_tz(time, format)
+    format_with_tz(time, format, use_utc)
 }
 
-fn format_with_tz(time: &DateTime<FixedOffset>, format: &str) -> String {
+fn format_with_tz(time: &DateTime<FixedOffset>, format: &str, use_utc: bool) -> String {
     if !format.contains("%Z") {
         return time.format(format).to_string();
     }
 
-    let tz_name = TZ_HANDLER.get_abbreviation(time.timestamp());
+    let tz_name = if use_utc {
+        String::from("UTC")
+    } else {
+        TZ_HANDLER.get_abbreviation(time.timestamp())
+    };
     let mut result = String::new();
     let mut last_end = 0;
     for (start, part) in format.match_indices("%Z") {

From 3e446a29112a4989fb970ea6d25944cbb79a6454 Mon Sep 17 00:00:00 2001
From: Alex Atkinson <alex@evilkittens.co>
Date: Sat, 28 Feb 2026 19:37:14 -0500
Subject: [PATCH 3/4] feat: Add UTC argument

---
 src/output/time.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/output/time.rs b/src/output/time.rs
index fb89e229e..b25304562 100644
--- a/src/output/time.rs
+++ b/src/output/time.rs
@@ -193,7 +193,7 @@ impl TimezoneHandler {
                     return String::new();
                 }
 
-                let idx = if tm.tm_isdst > 0 { 1 } else { 0 };
+                let idx = usize::from(tm.tm_isdst > 0);
                 let ptr = tzname[idx];
                 if ptr.is_null() {
                     return String::new();

From 83ae1c8db5443ea10b45790dd1c85a67f917a46d Mon Sep 17 00:00:00 2001
From: Alex Atkinson <alex@evilkittens.co>
Date: Sun, 1 Mar 2026 02:29:31 -0500
Subject: [PATCH 4/4] fix: feature edition2024 is required -- stabilized in
 1.85

---
 Cargo.lock          | 20 ++++++++++----------
 rust-toolchain.toml |  2 +-
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 593200711..84e2b92a1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1,6 +1,6 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
-version = 3
+version = 4
 
 [[package]]
 name = "addr2line"
@@ -894,9 +894,9 @@ dependencies = [
 
 [[package]]
 name = "num-conv"
-version = "0.1.0"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
+checksum = "cf97ec579c3c42f953ef76dbf8d55ac91fb219dde70e49aa4a6b7d74e9919050"
 
 [[package]]
 name = "num-traits"
@@ -1490,30 +1490,30 @@ dependencies = [
 
 [[package]]
 name = "time"
-version = "0.3.44"
+version = "0.3.47"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91e7d9e3bb61134e77bde20dd4825b97c010155709965fedf0f49bb138e52a9d"
+checksum = "743bd48c283afc0388f9b8827b976905fb217ad9e647fae3a379a9283c4def2c"
 dependencies = [
  "deranged",
  "itoa",
  "num-conv",
  "powerfmt",
- "serde",
+ "serde_core",
  "time-core",
  "time-macros",
 ]
 
 [[package]]
 name = "time-core"
-version = "0.1.6"
+version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40868e7c1d2f0b8d73e4a8c7f0ff63af4f6d19be117e90bd73eb1d62cf831c6b"
+checksum = "7694e1cfe791f8d31026952abf09c69ca6f6fa4e1a1229e18988f06a04a12dca"
 
 [[package]]
 name = "time-macros"
-version = "0.2.24"
+version = "0.2.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30cfb0125f12d9c277f35663a0a33f8c30190f4e4574868a330595412d34ebf3"
+checksum = "2e70e4c5a0e0a8a4823ad65dfe1a6930e4f4d756dcd9dd7939022b5e8c501215"
 dependencies = [
  "num-conv",
  "time-core",
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index 584eae38e..47e52b75c 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -2,7 +2,7 @@
 # SPDX-License-Identifier: EUPL-1.2
 [toolchain]
 # NOTE: don't forget to update the unit-tests workflow when changing this
-channel = "1.83"
+channel = "1.85.0"
 components = [
   "rustfmt",
   "rustc",