Precision & resolution

Temporal.Now.instant().epochNanoseconds; // BigInt nanoseconds
Date.now();                              // milliseconds (number)
// Comparing a ms value to a Unix SECOND is off by 1000x.

JS examples use Temporal — standardized in ES2026, available via a polyfill today.

import time

time.time()     # float seconds since the epoch, e.g. 1780665600.123
time.time_ns()  # int nanoseconds,             e.g. 1780665600123456789
# Comparing a seconds value to an ns value is off by 1,000,000,000x.

import java.time.Instant;

Instant now = Instant.now();
now.toEpochMilli();  // long milliseconds, e.g. 1783033290563
now.getNano();       // int nanoseconds within the current second
new java.util.Date().getTime();  // legacy: also epoch milliseconds, nothing finer
// Comparing a ms value to a Unix SECOND is off by 1000x.

Java examples use java.time (JSR-310) — see the Java page for the legacy java.util.Date minefield.

import kotlin.time.Clock

val now = Clock.System.now()
now.toEpochMilliseconds()   // Long milliseconds, e.g. 1783033290563
now.nanosecondsOfSecond     // Int nanoseconds within the current second
java.util.Date().time       // legacy: also epoch milliseconds, nothing finer
// Comparing a ms value to a Unix SECOND is off by 1000x.

Kotlin examples use kotlinx-datetime, JetBrains’ library — separate from the stdlib.

import Foundation

Date().timeIntervalSince1970   // Double seconds, e.g. 1783033423.42867
// A Double holds ~microsecond precision at 2026 epoch values — and mixing
// it with ms or ns integers is off by 1000x per unit step.

Swift examples use Foundation’s Calendar/DateComponents — see the Swift page.

import (
	"fmt"
	"time"
)

now := time.Now()
fmt.Println(now.Unix())      // seconds,      e.g. 1783033290
fmt.Println(now.UnixMilli()) // milliseconds, e.g. 1783033290563
fmt.Println(now.UnixNano())  // nanoseconds,  e.g. 1783033290563123456
// Comparing a ms value to a Unix SECOND is off by 1000x.

Go examples use the standard library’s time package — see the Go page.

use jiff::Timestamp;

let now = Timestamp::now();
println!("{}", now.as_millisecond());    // i64 milliseconds, e.g. 1783033290563
println!("{}", now.subsec_nanosecond()); // i32 nanoseconds within the second
// std::time::SystemTime spans the same epoch as (seconds, nanos) — comparing
// a ms value to a Unix SECOND is off by 1000x.

Rust examples use jiff, a third-party crate — Rust’s std has no calendar types at all.

#include <stdio.h>
#include <time.h>

struct timespec ts;
clock_gettime(CLOCK_REALTIME, &ts);
printf("%lld.%09ld\n", (long long)ts.tv_sec, ts.tv_nsec); // seconds + nanoseconds, e.g. 1783143908.090800295
printf("%lld\n", (long long)time(NULL));                  // whole seconds only,        e.g. 1783143908
// CLOCK_MONOTONIC (not CLOCK_REALTIME) is the clock for measuring elapsed time.
// Comparing a seconds value to a nanoseconds value is off by 1,000,000,000x.

C examples use <time.h> — see the C page. Standard C has no zone-aware or date-only type; the zone is a process-global set by TZ.

#include <chrono>
#include <iostream>
using namespace std::chrono;

auto now = system_clock::now().time_since_epoch();
std::cout << duration_cast<milliseconds>(now).count() << "\n"; // milliseconds since epoch
std::cout << duration_cast<nanoseconds>(now).count() << "\n";  // nanoseconds since epoch
// steady_clock (not system_clock) is the monotonic clock for elapsed time.
// Comparing a ms value to a Unix SECOND is off by 1000x.

C++ examples use std::chrono (C++20) — see the C++ page. The pre-C++20 world lived on C’s <time.h>.