Best Date-Time Libraries by Programming Language

Modern, immutable datetime library built on the Intl API with excellent timezone support

import { DateTime } from 'luxon';

const dt = DateTime.now().setZone('America/New_York');
const iso = dt.toISO();
const unix = dt.toSeconds();

Lightweight Moment.js alternative with plugin architecture

import dayjs from 'dayjs';
import timezone from 'dayjs/plugin/timezone';

dayjs.extend(timezone);
const time = dayjs().tz('America/New_York').format();

Functional programming approach with tree-shakeable functions

import { format, parseISO } from 'date-fns';
import { utcToZonedTime } from 'date-fns-tz';

const date = utcToZonedTime(new Date(), 'America/New_York');
const formatted = format(date, 'yyyy-MM-dd HH:mm:ssXXX');

Legacy datetime library (no longer recommended for new projects)

// Use Luxon or Day.js instead for new projects
import moment from 'moment-timezone';

const time = moment().tz('America/New_York').format();

Modern date/time API for JavaScript (proposal, requires polyfill)

import { Temporal } from '@js-temporal/polyfill';

const now = Temporal.Now.zonedDateTimeISO('America/New_York');
const instant = now.toInstant();

Python standard library for date and time manipulation

from datetime import datetime, timezone

now = datetime.now(timezone.utc)
timestamp = now.timestamp()
iso = now.isoformat()

Accurate timezone calculations using the IANA database

import pytz
from datetime import datetime

tz = pytz.timezone('America/New_York')
dt = datetime.now(tz)
utc = dt.astimezone(pytz.UTC)

Modern timezone support built into Python 3.9+

from datetime import datetime
from zoneinfo import ZoneInfo

tz = ZoneInfo('America/New_York')
dt = datetime.now(tz)
iso = dt.isoformat()

Human-friendly datetime library for Python

import arrow

now = arrow.now('America/New_York')
timestamp = now.timestamp()
humanized = now.humanize()  # "just now"

Python datetime library with better timezone handling than native

import pendulum

now = pendulum.now('America/New_York')
diff = now.diff_for_humans()
iso = now.to_iso8601_string()

Modern date-time API introduced in Java 8

import java.time.*;

ZonedDateTime now = ZonedDateTime.now(ZoneId.of("America/New_York"));
Instant instant = now.toInstant();
long epoch = instant.getEpochSecond();

Quality replacement for Java date/time classes (pre-Java 8)

// Use java.time instead for Java 8+
import org.joda.time.*;

DateTime now = DateTime.now(DateTimeZone.forID("America/New_York"));
long millis = now.getMillis();

Backport of JSR-310 (java.time) to Java 6 and 7

import org.threeten.bp.*;

ZonedDateTime now = ZonedDateTime.now(ZoneId.of("America/New_York"));
Instant instant = now.toInstant();

PHP built-in datetime classes with timezone support

<?php
$dt = new DateTimeImmutable('now', new DateTimeZone('America/New_York'));
$timestamp = $dt->getTimestamp();
$iso = $dt->format(DateTime::ATOM);

Human-friendly extension of DateTime with many conveniences

<?php
use Carbon\Carbon;

$now = Carbon::now('America/New_York');
$timestamp = $now->timestamp;
$humanized = $now->diffForHumans();  // "just now"

Carbon alternative focused on immutability and consistency

<?php
use Cake\Chronos\Chronos;

$now = Chronos::now('America/New_York');
$timestamp = $now->timestamp;
$modified = $now->addDays(5);  // Returns new instance

Ruby built-in Time class with timezone support

require 'time'

now = Time.now
timestamp = now.to_i
iso = now.iso8601

Rails timezone-aware time implementation

require 'active_support/time'

Time.zone = 'America/New_York'
now = Time.zone.now
timestamp = now.to_i
humanized = now.to_s(:long)

Timezone library providing support for IANA timezone database

require 'tzinfo'

tz = TZInfo::Timezone.get('America/New_York')
now = tz.now
local_time = tz.to_local(Time.now.utc)

Go standard library time package with excellent timezone support

package main

import "time"

func main() {
    loc, _ := time.LoadLocation("America/New_York")
    now := time.Now().In(loc)
    unix := now.Unix()
    iso := now.Format(time.RFC3339)
}

Time toolkit for Go with useful helpers

package main

import "github.com/jinzhu/now"

func main() {
    beginning := now.BeginningOfMonth()
    end := now.EndOfDay()
    monday := now.Monday()
}

Carbon-like API for Go (inspired by PHP Carbon)

package main

import "github.com/golang-module/carbon/v2"

func main() {
    now := carbon.Now("America/New_York")
    timestamp := now.Timestamp()
    humanized := now.DiffForHumans()
}

.NET built-in datetime types with timezone support

using System;

var now = DateTimeOffset.Now;
var utc = DateTimeOffset.UtcNow;
var timestamp = now.ToUnixTimeSeconds();
var iso = now.ToString("o");

Better date and time API for .NET (by Jon Skeet)

using NodaTime;

var zone = DateTimeZoneProviders.Tzdb["America/New_York"];
var now = SystemClock.Instance.GetCurrentInstant().InZone(zone);
var timestamp = now.ToInstant().ToUnixTimeSeconds();

Date and time library for Rust

use chrono::{DateTime, Utc, TimeZone};

let now: DateTime<Utc> = Utc::now();
let timestamp = now.timestamp();
let iso = now.to_rfc3339();

Modern date and time library for Rust

use time::OffsetDateTime;

let now = OffsetDateTime::now_utc();
let timestamp = now.unix_timestamp();
let iso = now.to_string();

Which JavaScript library should I use?

For most projects: Luxon (best timezone support) or Day.js (smallest bundle). Use date-fns if you prefer functional programming. Avoid Moment.js for new projects.

Do I need a library at all?

For simple UTC timestamps and formatting, native Date might be enough. Add a library when you need: accurate timezone conversions, complex date arithmetic, or localization.

What about Python 3.9+ projects?

Use built-in datetime + zoneinfo. No external dependencies needed. For older Python, use pytz.

Should I use Carbon in PHP?

Yes for Laravel projects (it's included). For pure PHP, built-in DateTimeImmutable is often sufficient. Add Carbon if you need human-friendly helpers.

Do I need NodaTime in .NET?

Not usually. DateTimeOffset handles most cases. Use NodaTime for: financial systems, complex timezone logic, or when you need better API design.

Bundle size vs features trade-off?

Small projects: Native APIs or minimal libraries (Day.js, native datetime). Large projects: Full-featured libraries (Luxon, Carbon) worth the extra KB.