From ef0fe384a0e20cfe94de39ac5a384607beb7d697 Mon Sep 17 00:00:00 2001
From: Jukka Lehtosalo <jukka@dropbox.com>
Date: Mon, 2 Feb 2026 15:25:40 +0000
Subject: [PATCH 1/7] WIP librt.time

---
 mypy/typeshed/stubs/librt/librt/time.pyi |  1 +
 mypyc/codegen/emitmodule.py              |  8 +-
 mypyc/ir/deps.py                         |  1 +
 mypyc/lib-rt/time/librt_time.c           | 99 ++++++++++++++++++++++++
 mypyc/lib-rt/time/librt_time.h           | 62 +++++++++++++++
 mypyc/primitives/librt_time_ops.py       | 14 ++++
 mypyc/primitives/registry.py             |  1 +
 mypyc/test-data/irbuild-time.test        | 44 +++++++++++
 mypyc/test/test_irbuild.py               |  1 +
 9 files changed, 230 insertions(+), 1 deletion(-)
 create mode 100644 mypy/typeshed/stubs/librt/librt/time.pyi
 create mode 100644 mypyc/lib-rt/time/librt_time.c
 create mode 100644 mypyc/lib-rt/time/librt_time.h
 create mode 100644 mypyc/primitives/librt_time_ops.py
 create mode 100644 mypyc/test-data/irbuild-time.test

diff --git a/mypy/typeshed/stubs/librt/librt/time.pyi b/mypy/typeshed/stubs/librt/librt/time.pyi
new file mode 100644
index 0000000000000..f0bb23fff8d00
--- /dev/null
+++ b/mypy/typeshed/stubs/librt/librt/time.pyi
@@ -0,0 +1 @@
+def time() -> float: ...
diff --git a/mypyc/codegen/emitmodule.py b/mypyc/codegen/emitmodule.py
index 2b0693ea2f2dd..da82f14e92f2e 100644
--- a/mypyc/codegen/emitmodule.py
+++ b/mypyc/codegen/emitmodule.py
@@ -56,7 +56,7 @@
     short_id_from_name,
 )
 from mypyc.errors import Errors
-from mypyc.ir.deps import LIBRT_BASE64, LIBRT_STRINGS, SourceDep
+from mypyc.ir.deps import LIBRT_BASE64, LIBRT_STRINGS, LIBRT_TIME, SourceDep
 from mypyc.ir.func_ir import FuncIR
 from mypyc.ir.module_ir import ModuleIR, ModuleIRs, deserialize_modules
 from mypyc.ir.ops import DeserMaps, LoadLiteral
@@ -632,6 +632,8 @@ def generate_c_for_modules(self) -> list[tuple[str, str]]:
             ext_declarations.emit_line("#include <base64/librt_base64.h>")
         if any(LIBRT_STRINGS in mod.dependencies for mod in self.modules.values()):
             ext_declarations.emit_line("#include <strings/librt_strings.h>")
+        if any(LIBRT_TIME in mod.dependencies for mod in self.modules.values()):
+            ext_declarations.emit_line("#include <time/librt_time.h>")
         # Include headers for conditional source files
         source_deps = collect_source_dependencies(self.modules)
         for source_dep in sorted(source_deps, key=lambda d: d.path):
@@ -1102,6 +1104,10 @@ def emit_module_exec_func(
             emitter.emit_line("if (import_librt_strings() < 0) {")
             emitter.emit_line("return -1;")
             emitter.emit_line("}")
+        if LIBRT_TIME in module.dependencies:
+            emitter.emit_line("if (import_librt_time() < 0) {")
+            emitter.emit_line("return -1;")
+            emitter.emit_line("}")
         emitter.emit_line("PyObject* modname = NULL;")
         if self.multi_phase_init:
             emitter.emit_line(f"{module_static} = module;")
diff --git a/mypyc/ir/deps.py b/mypyc/ir/deps.py
index 7c52520e274b9..1bb2d8ad3a0a3 100644
--- a/mypyc/ir/deps.py
+++ b/mypyc/ir/deps.py
@@ -49,6 +49,7 @@ def get_header(self) -> str:
 LIBRT_STRINGS: Final = Capsule("librt.strings")
 LIBRT_BASE64: Final = Capsule("librt.base64")
 LIBRT_VECS: Final = Capsule("librt.vecs")
+LIBRT_TIME: Final = Capsule("librt.time")
 
 BYTES_EXTRA_OPS: Final = SourceDep("bytes_extra_ops.c")
 BYTES_WRITER_EXTRA_OPS: Final = SourceDep("byteswriter_extra_ops.c")
diff --git a/mypyc/lib-rt/time/librt_time.c b/mypyc/lib-rt/time/librt_time.c
new file mode 100644
index 0000000000000..b7480c1298f6e
--- /dev/null
+++ b/mypyc/lib-rt/time/librt_time.c
@@ -0,0 +1,99 @@
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+#include <time.h>
+#include "librt_time.h"
+#include "../pythoncapi_compat.h"
+#include "../mypyc_util.h"
+
+#ifdef MYPYC_EXPERIMENTAL
+
+// Internal function that returns a C double for mypyc primitives
+static double
+time_time_internal(void) {
+    time_t t = time(NULL);
+    if (unlikely(t == (time_t)-1)) {
+        PyErr_SetString(PyExc_OSError, "time() failed");
+        return CPY_FLOAT_ERROR;
+    }
+    return (double)t;
+}
+
+// Wrapper function for normal Python extension usage
+static PyObject*
+time_time(PyObject *self, PyObject *const *args, size_t nargs) {
+    if (nargs != 0) {
+        PyErr_SetString(PyExc_TypeError, "time() takes no arguments");
+        return NULL;
+    }
+
+    double result = time_time_internal();
+    if (result == CPY_FLOAT_ERROR) {
+        return NULL;
+    }
+    return PyFloat_FromDouble(result);
+}
+
+#endif
+
+static PyMethodDef librt_time_module_methods[] = {
+#ifdef MYPYC_EXPERIMENTAL
+    {"time", (PyCFunction)time_time, METH_FASTCALL,
+     PyDoc_STR("Return the current time in seconds since the Unix epoch as a floating point number.")},
+#endif
+    {NULL, NULL, 0, NULL}
+};
+
+#ifdef MYPYC_EXPERIMENTAL
+
+static int
+time_abi_version(void) {
+    return LIBRT_TIME_ABI_VERSION;
+}
+
+static int
+time_api_version(void) {
+    return LIBRT_TIME_API_VERSION;
+}
+
+#endif
+
+static int
+librt_time_module_exec(PyObject *m)
+{
+#ifdef MYPYC_EXPERIMENTAL
+    // Export mypyc internal C API via capsule
+    static void *time_api[LIBRT_TIME_API_LEN] = {
+        (void *)time_abi_version,
+        (void *)time_api_version,
+        (void *)time_time_internal,
+    };
+    PyObject *c_api_object = PyCapsule_New((void *)time_api, "librt.time._C_API", NULL);
+    if (PyModule_Add(m, "_C_API", c_api_object) < 0) {
+        return -1;
+    }
+#endif
+    return 0;
+}
+
+static PyModuleDef_Slot librt_time_module_slots[] = {
+    {Py_mod_exec, librt_time_module_exec},
+#ifdef Py_MOD_GIL_NOT_USED
+    {Py_mod_gil, Py_MOD_GIL_NOT_USED},
+#endif
+    {0, NULL}
+};
+
+static PyModuleDef librt_time_module = {
+    .m_base = PyModuleDef_HEAD_INIT,
+    .m_name = "time",
+    .m_doc = "Fast time() function optimized for mypyc",
+    .m_size = 0,
+    .m_methods = librt_time_module_methods,
+    .m_slots = librt_time_module_slots,
+};
+
+PyMODINIT_FUNC
+PyInit_time(void)
+{
+    return PyModuleDef_Init(&librt_time_module);
+}
diff --git a/mypyc/lib-rt/time/librt_time.h b/mypyc/lib-rt/time/librt_time.h
new file mode 100644
index 0000000000000..72a1f52920bc8
--- /dev/null
+++ b/mypyc/lib-rt/time/librt_time.h
@@ -0,0 +1,62 @@
+#ifndef LIBRT_TIME_H
+#define LIBRT_TIME_H
+
+#ifndef MYPYC_EXPERIMENTAL
+
+static int
+import_librt_time(void)
+{
+    // All librt.time features are experimental for now, so don't set up the API here
+    return 0;
+}
+
+#else  // MYPYC_EXPERIMENTAL
+
+#include <Python.h>
+
+#define LIBRT_TIME_ABI_VERSION 1
+#define LIBRT_TIME_API_VERSION 1
+#define LIBRT_TIME_API_LEN 3
+
+static void *LibRTTime_API[LIBRT_TIME_API_LEN];
+
+#define LibRTTime_ABIVersion (*(int (*)(void)) LibRTTime_API[0])
+#define LibRTTime_APIVersion (*(int (*)(void)) LibRTTime_API[1])
+#define LibRTTime_time (*(double (*)(void)) LibRTTime_API[2])
+
+static int
+import_librt_time(void)
+{
+    PyObject *mod = PyImport_ImportModule("librt.time");
+    if (mod == NULL)
+        return -1;
+    Py_DECREF(mod);  // we import just for the side effect of making the below work.
+    void *capsule = PyCapsule_Import("librt.time._C_API", 0);
+    if (capsule == NULL)
+        return -1;
+    memcpy(LibRTTime_API, capsule, sizeof(LibRTTime_API));
+    if (LibRTTime_ABIVersion() != LIBRT_TIME_ABI_VERSION) {
+        char err[128];
+        snprintf(err, sizeof(err), "ABI version conflict for librt.time, expected %d, found %d",
+            LIBRT_TIME_ABI_VERSION,
+            LibRTTime_ABIVersion()
+        );
+        PyErr_SetString(PyExc_ValueError, err);
+        return -1;
+    }
+    if (LibRTTime_APIVersion() < LIBRT_TIME_API_VERSION) {
+        char err[128];
+        snprintf(err, sizeof(err),
+                 "API version conflict for librt.time, expected %d or newer, found %d (hint: upgrade librt)",
+            LIBRT_TIME_API_VERSION,
+            LibRTTime_APIVersion()
+        );
+        PyErr_SetString(PyExc_ValueError, err);
+        return -1;
+    }
+    return 0;
+}
+
+#endif  // MYPYC_EXPERIMENTAL
+
+#endif  // LIBRT_TIME_H
diff --git a/mypyc/primitives/librt_time_ops.py b/mypyc/primitives/librt_time_ops.py
new file mode 100644
index 0000000000000..ad8737f84b7db
--- /dev/null
+++ b/mypyc/primitives/librt_time_ops.py
@@ -0,0 +1,14 @@
+from mypyc.ir.deps import LIBRT_TIME
+from mypyc.ir.ops import ERR_MAGIC_OVERLAPPING
+from mypyc.ir.rtypes import float_rprimitive
+from mypyc.primitives.registry import function_op
+
+function_op(
+    name="librt.time.time",
+    arg_types=[],
+    return_type=float_rprimitive,
+    c_function_name="LibRTTime_time",
+    error_kind=ERR_MAGIC_OVERLAPPING,
+    experimental=True,
+    dependencies=[LIBRT_TIME],
+)
diff --git a/mypyc/primitives/registry.py b/mypyc/primitives/registry.py
index 0e3032719ca12..e0aeaf6749fdc 100644
--- a/mypyc/primitives/registry.py
+++ b/mypyc/primitives/registry.py
@@ -394,6 +394,7 @@ def load_address_op(name: str, type: RType, src: str) -> LoadAddressDescription:
 import mypyc.primitives.float_ops
 import mypyc.primitives.int_ops
 import mypyc.primitives.librt_strings_ops
+import mypyc.primitives.librt_time_ops
 import mypyc.primitives.list_ops
 import mypyc.primitives.misc_ops
 import mypyc.primitives.str_ops
diff --git a/mypyc/test-data/irbuild-time.test b/mypyc/test-data/irbuild-time.test
new file mode 100644
index 0000000000000..9b010892d79a6
--- /dev/null
+++ b/mypyc/test-data/irbuild-time.test
@@ -0,0 +1,44 @@
+[case testTime_experimental]
+from librt.time import time
+
+def get_time() -> float:
+    return time()
+
+def time_twice() -> float:
+    t1 = time()
+    t2 = time()
+    return t2 - t1
+[out]
+def get_time():
+    r0 :: float
+L0:
+    r0 = LibRTTime_time()
+    return r0
+def time_twice():
+    r0, t1, r1, t2, r2 :: float
+L0:
+    r0 = LibRTTime_time()
+    t1 = r0
+    r1 = LibRTTime_time()
+    t2 = r1
+    r2 = t2 - t1
+    return r2
+
+[case testTimeExperimentalDisabled]
+from librt.time import time
+
+def get_time() -> float:
+    return time()
+[out]
+def get_time():
+    r0 :: dict
+    r1 :: str
+    r2, r3 :: object
+    r4 :: float
+L0:
+    r0 = __main__.globals :: static
+    r1 = 'time'
+    r2 = CPyDict_GetItem(r0, r1)
+    r3 = PyObject_Vectorcall(r2, 0, 0, 0)
+    r4 = unbox(float, r3)
+    return r4
diff --git a/mypyc/test/test_irbuild.py b/mypyc/test/test_irbuild.py
index 707ee11428626..2744ee0631c71 100644
--- a/mypyc/test/test_irbuild.py
+++ b/mypyc/test/test_irbuild.py
@@ -55,6 +55,7 @@
     "irbuild-weakref.test",
     "irbuild-librt-strings.test",
     "irbuild-base64.test",
+    "irbuild-time.test",
     "irbuild-match.test",
 ]
 

From cf1a324f605960896d9fdd241ff7af9d0b934624 Mon Sep 17 00:00:00 2001
From: Jukka Lehtosalo <jukka@dropbox.com>
Date: Wed, 21 Jan 2026 13:35:58 +0000
Subject: [PATCH 2/7] Build extension + add run test

---
 mypyc/build.py                      |  1 +
 mypyc/lib-rt/setup.py               |  8 +++++
 mypyc/lib-rt/time/librt_time.c      |  4 +--
 mypyc/test-data/run-librt-time.test | 45 +++++++++++++++++++++++++++++
 mypyc/test/test_run.py              |  1 +
 5 files changed, 57 insertions(+), 2 deletions(-)
 create mode 100644 mypyc/test-data/run-librt-time.test

diff --git a/mypyc/build.py b/mypyc/build.py
index 026db45471086..fae2c72ba4e59 100644
--- a/mypyc/build.py
+++ b/mypyc/build.py
@@ -120,6 +120,7 @@ class ModDesc(NamedTuple):
         ["vecs/librt_vecs.h", "vecs/vec_template.c"],
         ["vecs"],
     ),
+    ModDesc("librt.time", ["time/librt_time.c"], ["time/librt_time.h"], []),
 ]
 
 try:
diff --git a/mypyc/lib-rt/setup.py b/mypyc/lib-rt/setup.py
index 1f9f48c22a77c..ebc73487cd916 100644
--- a/mypyc/lib-rt/setup.py
+++ b/mypyc/lib-rt/setup.py
@@ -148,5 +148,13 @@ def run(self) -> None:
                 include_dirs=[".", "vecs"],
                 extra_compile_args=cflags,
             ),
+            Extension(
+                "librt.time",
+                [
+                    "time/librt_time.c",
+                ],
+                include_dirs=["."],
+                extra_compile_args=cflags,
+            ),
         ]
     )
diff --git a/mypyc/lib-rt/time/librt_time.c b/mypyc/lib-rt/time/librt_time.c
index b7480c1298f6e..1561674343f54 100644
--- a/mypyc/lib-rt/time/librt_time.c
+++ b/mypyc/lib-rt/time/librt_time.c
@@ -2,8 +2,8 @@
 #include <Python.h>
 #include <time.h>
 #include "librt_time.h"
-#include "../pythoncapi_compat.h"
-#include "../mypyc_util.h"
+#include "pythoncapi_compat.h"
+#include "mypyc_util.h"
 
 #ifdef MYPYC_EXPERIMENTAL
 
diff --git a/mypyc/test-data/run-librt-time.test b/mypyc/test-data/run-librt-time.test
new file mode 100644
index 0000000000000..e769428c540d6
--- /dev/null
+++ b/mypyc/test-data/run-librt-time.test
@@ -0,0 +1,45 @@
+[case testTimeBasic_librt_experimental]
+import time as stdlib_time
+from librt.time import time
+
+def test_time_returns_float() -> None:
+    result = time()
+    assert isinstance(result, float)
+
+def test_time_is_reasonable() -> None:
+    # Should return a Unix timestamp, which should be a large positive number
+    result = time()
+    # Check it's after year 2020 (timestamp > 1577836800)
+    assert result > 1577836800.0
+    # Check it's before year 2100 (timestamp < 4102444800)
+    assert result < 4102444800.0
+
+def test_time_increments() -> None:
+    t1 = time()
+    t2 = time()
+    # Time should not go backwards (allowing for same value due to precision)
+    assert t2 >= t1
+
+def test_time_comparable_to_stdlib() -> None:
+    # Our time() should return similar values to stdlib time.time()
+    our_time = time()
+    std_time = stdlib_time.time()
+    # Should be within 1 second of each other (very generous)
+    assert abs(our_time - std_time) < 1.0
+
+[case testTimeNotAvailableInNonExperimentalBuild_librt_time]
+# This also ensures librt.time can be built without experimental features
+import librt.time
+
+def test_time_not_available() -> None:
+    assert not hasattr(librt.time, "time")
+
+[case testTimeUsedAtTopLevelOnly_librt_experimental]
+from librt.time import time
+
+# The only reference to time() is at module top level
+current_time = time()
+
+def test_top_level_only_time() -> None:
+    assert isinstance(current_time, float)
+    assert current_time > 0.0
diff --git a/mypyc/test/test_run.py b/mypyc/test/test_run.py
index 7b855841e220f..56852f9ea3a9c 100644
--- a/mypyc/test/test_run.py
+++ b/mypyc/test/test_run.py
@@ -77,6 +77,7 @@
     "run-python38.test",
     "run-librt-strings.test",
     "run-base64.test",
+    "run-librt-time.test",
     "run-match.test",
     "run-vecs-i64-interp.test",
     "run-vecs-misc-interp.test",

From e08743eaf5886a599b4e41b2cd99e4bb14472704 Mon Sep 17 00:00:00 2001
From: Jukka Lehtosalo <jukka@dropbox.com>
Date: Wed, 21 Jan 2026 15:50:52 +0000
Subject: [PATCH 3/7] Return fractional seconds

---
 mypyc/lib-rt/time/librt_time.c | 71 ++++++++++++++++++++++++++++++++--
 1 file changed, 67 insertions(+), 4 deletions(-)

diff --git a/mypyc/lib-rt/time/librt_time.c b/mypyc/lib-rt/time/librt_time.c
index 1561674343f54..539186eddd158 100644
--- a/mypyc/lib-rt/time/librt_time.c
+++ b/mypyc/lib-rt/time/librt_time.c
@@ -1,21 +1,84 @@
 #define PY_SSIZE_T_CLEAN
 #include <Python.h>
 #include <time.h>
+#include <stdint.h>
 #include "librt_time.h"
 #include "pythoncapi_compat.h"
 #include "mypyc_util.h"
 
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <sys/time.h>
+#endif
+
 #ifdef MYPYC_EXPERIMENTAL
 
+// Helper to convert nanoseconds to double seconds (similar to PyTime_AsSecondsDouble)
+// Uses volatile to avoid compiler optimizations that could change rounding behavior
+static inline double
+ns_to_double(int64_t ns) {
+    volatile double d;
+
+    if (ns % 1000000000LL == 0) {
+        // Exact seconds: divide using integers to avoid floating-point rounding issues
+        // (1e-9 cannot be exactly represented in IEEE 754 double precision)
+        int64_t secs = ns / 1000000000LL;
+        d = (double)secs;
+    }
+    else {
+        // Has fractional seconds
+        d = (double)ns;
+        d /= 1e9;
+    }
+    return d;
+}
+
 // Internal function that returns a C double for mypyc primitives
+// Returns high-precision time in seconds (like time.time())
 static double
 time_time_internal(void) {
-    time_t t = time(NULL);
-    if (unlikely(t == (time_t)-1)) {
-        PyErr_SetString(PyExc_OSError, "time() failed");
+#ifdef _WIN32
+    // Windows: Use GetSystemTimePreciseAsFileTime for ~100ns precision
+    FILETIME ft;
+    ULARGE_INTEGER large;
+
+    GetSystemTimePreciseAsFileTime(&ft);
+    large.LowPart = ft.dwLowDateTime;
+    large.HighPart = ft.dwHighDateTime;
+
+    // Windows FILETIME is 100-nanosecond intervals since January 1, 1601
+    // Convert to nanoseconds since Unix epoch (January 1, 1970)
+    // 116444736000000000 = number of 100-ns intervals between 1601 and 1970
+    int64_t ns = (large.QuadPart - 116444736000000000LL) * 100LL;
+    return ns_to_double(ns);
+
+#else  // Unix-like systems (Linux, macOS, BSD, etc.)
+
+    // Try clock_gettime(CLOCK_REALTIME) for nanosecond precision
+    // This is available on POSIX.1-2001 and later (widely available on modern systems)
+#if defined(_POSIX_TIMERS) && _POSIX_TIMERS > 0
+    struct timespec ts;
+    if (clock_gettime(CLOCK_REALTIME, &ts) == 0) {
+        // Convert to nanoseconds
+        int64_t ns = (int64_t)ts.tv_sec * 1000000000LL + (int64_t)ts.tv_nsec;
+        return ns_to_double(ns);
+    }
+    // Fall through to gettimeofday if clock_gettime failed
+#endif
+
+    // Fallback: gettimeofday for microsecond precision
+    // This is widely available (POSIX.1-2001, BSD, etc.)
+    struct timeval tv;
+    if (unlikely(gettimeofday(&tv, NULL) != 0)) {
+        PyErr_SetFromErrno(PyExc_OSError);
         return CPY_FLOAT_ERROR;
     }
-    return (double)t;
+
+    // Convert to nanoseconds
+    int64_t ns = (int64_t)tv.tv_sec * 1000000000LL + (int64_t)tv.tv_usec * 1000LL;
+    return ns_to_double(ns);
+#endif
 }
 
 // Wrapper function for normal Python extension usage

From b4e9e957be737f02d71c7d232782f906b3c57033 Mon Sep 17 00:00:00 2001
From: Jukka Lehtosalo <jukka@dropbox.com>
Date: Thu, 22 Jan 2026 10:08:57 +0000
Subject: [PATCH 4/7] Update irbuild test

---
 mypyc/test-data/irbuild-time.test | 21 ++++++++-------------
 1 file changed, 8 insertions(+), 13 deletions(-)

diff --git a/mypyc/test-data/irbuild-time.test b/mypyc/test-data/irbuild-time.test
index 9b010892d79a6..5658bb2922be1 100644
--- a/mypyc/test-data/irbuild-time.test
+++ b/mypyc/test-data/irbuild-time.test
@@ -1,28 +1,23 @@
 [case testTime_experimental]
 from librt.time import time
+import librt.time
 
-def get_time() -> float:
+def t1() -> float:
     return time()
 
-def time_twice() -> float:
-    t1 = time()
-    t2 = time()
-    return t2 - t1
+def t2() -> float:
+    return librt.time.time()
 [out]
-def get_time():
+def t1():
     r0 :: float
 L0:
     r0 = LibRTTime_time()
     return r0
-def time_twice():
-    r0, t1, r1, t2, r2 :: float
+def t2():
+    r0 :: float
 L0:
     r0 = LibRTTime_time()
-    t1 = r0
-    r1 = LibRTTime_time()
-    t2 = r1
-    r2 = t2 - t1
-    return r2
+    return r0
 
 [case testTimeExperimentalDisabled]
 from librt.time import time

From a0b671ff0644a049b898a3fb2550f9a637ad2c57 Mon Sep 17 00:00:00 2001
From: Jukka Lehtosalo <jukka@dropbox.com>
Date: Thu, 22 Jan 2026 11:32:51 +0000
Subject: [PATCH 5/7] Optimize

---
 mypyc/lib-rt/time/librt_time.c | 36 +++++++---------------------------
 1 file changed, 7 insertions(+), 29 deletions(-)

diff --git a/mypyc/lib-rt/time/librt_time.c b/mypyc/lib-rt/time/librt_time.c
index 539186eddd158..21ec86739b5d5 100644
--- a/mypyc/lib-rt/time/librt_time.c
+++ b/mypyc/lib-rt/time/librt_time.c
@@ -14,26 +14,6 @@
 
 #ifdef MYPYC_EXPERIMENTAL
 
-// Helper to convert nanoseconds to double seconds (similar to PyTime_AsSecondsDouble)
-// Uses volatile to avoid compiler optimizations that could change rounding behavior
-static inline double
-ns_to_double(int64_t ns) {
-    volatile double d;
-
-    if (ns % 1000000000LL == 0) {
-        // Exact seconds: divide using integers to avoid floating-point rounding issues
-        // (1e-9 cannot be exactly represented in IEEE 754 double precision)
-        int64_t secs = ns / 1000000000LL;
-        d = (double)secs;
-    }
-    else {
-        // Has fractional seconds
-        d = (double)ns;
-        d /= 1e9;
-    }
-    return d;
-}
-
 // Internal function that returns a C double for mypyc primitives
 // Returns high-precision time in seconds (like time.time())
 static double
@@ -48,10 +28,10 @@ time_time_internal(void) {
     large.HighPart = ft.dwHighDateTime;
 
     // Windows FILETIME is 100-nanosecond intervals since January 1, 1601
-    // Convert to nanoseconds since Unix epoch (January 1, 1970)
     // 116444736000000000 = number of 100-ns intervals between 1601 and 1970
-    int64_t ns = (large.QuadPart - 116444736000000000LL) * 100LL;
-    return ns_to_double(ns);
+    // Convert directly to seconds: 100ns * 1e-9 = 1e-7
+    int64_t intervals = large.QuadPart - 116444736000000000LL;
+    return (double)intervals * 1e-7;
 
 #else  // Unix-like systems (Linux, macOS, BSD, etc.)
 
@@ -60,9 +40,8 @@ time_time_internal(void) {
 #if defined(_POSIX_TIMERS) && _POSIX_TIMERS > 0
     struct timespec ts;
     if (clock_gettime(CLOCK_REALTIME, &ts) == 0) {
-        // Convert to nanoseconds
-        int64_t ns = (int64_t)ts.tv_sec * 1000000000LL + (int64_t)ts.tv_nsec;
-        return ns_to_double(ns);
+        // Convert seconds and nanoseconds separately to avoid large integer operations
+        return (double)ts.tv_sec + (double)ts.tv_nsec * 1e-9;
     }
     // Fall through to gettimeofday if clock_gettime failed
 #endif
@@ -75,9 +54,8 @@ time_time_internal(void) {
         return CPY_FLOAT_ERROR;
     }
 
-    // Convert to nanoseconds
-    int64_t ns = (int64_t)tv.tv_sec * 1000000000LL + (int64_t)tv.tv_usec * 1000LL;
-    return ns_to_double(ns);
+    // Convert seconds and microseconds separately to avoid large integer operations
+    return (double)tv.tv_sec + (double)tv.tv_usec * 1e-6;
 #endif
 }
 

From ed0ec213a68636f82fdfb4b6056d82950a4f4e33 Mon Sep 17 00:00:00 2001
From: Jukka Lehtosalo <jukka@dropbox.com>
Date: Thu, 22 Jan 2026 11:39:31 +0000
Subject: [PATCH 6/7] Tighten threshold in test

---
 mypyc/test-data/run-librt-time.test | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/mypyc/test-data/run-librt-time.test b/mypyc/test-data/run-librt-time.test
index e769428c540d6..40baa50a7fa4b 100644
--- a/mypyc/test-data/run-librt-time.test
+++ b/mypyc/test-data/run-librt-time.test
@@ -24,8 +24,9 @@ def test_time_comparable_to_stdlib() -> None:
     # Our time() should return similar values to stdlib time.time()
     our_time = time()
     std_time = stdlib_time.time()
-    # Should be within 1 second of each other (very generous)
-    assert abs(our_time - std_time) < 1.0
+    # Should be within 0.25 seconds of each other (usually should be much less,
+    # but keep it relatively high to avoid test flakiness in CI)
+    assert abs(our_time - std_time) < 0.25
 
 [case testTimeNotAvailableInNonExperimentalBuild_librt_time]
 # This also ensures librt.time can be built without experimental features

From 8b6065d4ed28d673b55dcca3e0230d71a393064f Mon Sep 17 00:00:00 2001
From: Jukka Lehtosalo <jukka@dropbox.com>
Date: Mon, 2 Feb 2026 16:05:17 +0000
Subject: [PATCH 7/7] Lint

---
 mypyc/lib-rt/setup.py | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/mypyc/lib-rt/setup.py b/mypyc/lib-rt/setup.py
index ebc73487cd916..49b6c10201317 100644
--- a/mypyc/lib-rt/setup.py
+++ b/mypyc/lib-rt/setup.py
@@ -149,12 +149,7 @@ def run(self) -> None:
                 extra_compile_args=cflags,
             ),
             Extension(
-                "librt.time",
-                [
-                    "time/librt_time.c",
-                ],
-                include_dirs=["."],
-                extra_compile_args=cflags,
+                "librt.time", ["time/librt_time.c"], include_dirs=["."], extra_compile_args=cflags
             ),
         ]
     )