Performance Observability Platform

Execution intelligence,
zero overhead.

Chrono wraps any process and delivers a complete performance profile — wall-clock time, CPU decomposition, memory forensics, I/O telemetry, and context-switch analytics. One command. Every metric.

Start Profiling Free See It In Action

chrono — performance profile

$ chrono make -j8 build

[████████████████████████] 100% compiled

3.87user 0.31system 0:04.23elapsed 98%CPU

(0avgtext+0avgdata 48256maxresident)k

1024inputs+256outputs (2major+1847minor)pagefaults 0swaps

Features

Every dimension of performance,
one execution away.

Chrono captures the complete performance fingerprint of any process. No agents. No SDKs. No config files.

⏱

Real-Time Intelligence

Elapsed wall-clock measurement with sub-second precision. Know exactly how long your process took in the real world — not just on the CPU.

%E elapsed real time

🧠

CPU Decomposition Engine

Instantly decompose execution into user-mode and kernel-mode CPU time. See whether you're compute-bound or syscall-bound in a single glance.

%U user · %S system · %P utilization

📊

Memory Forensics Suite

Full memory lifecycle analytics — peak resident set size, average total memory, shared text, unshared data, and stack — all captured automatically.

%M max RSS · %K avg total · %X shared

⚡

Page Fault Radar

Detect major (disk-backed) and minor (reclaimed) page faults before they cascade into production incidents. Every fault, counted and classified.

%F major · %R minor · %W swaps

💾

I/O Telemetry

Every filesystem read, every write, every socket message — captured and surfaced. Know your process's exact I/O footprint without strace.

%I inputs · %O outputs · %r/%s sockets

🔄

Context Switch Analytics

Understand exactly when and why your process yields the CPU. Separate voluntary waits from involuntary preemptions to diagnose scheduling pressure.

%w voluntary · %c involuntary

How It Works

From zero to full observability in four steps.

Instrument

Prefix any command with chrono. No agents to install, no config files to maintain, no SDKs to integrate. One word, and you're profiling.

$ chrono <your-command>

Execute

Chrono runs your process in a fully instrumented profiling context, capturing every metric in real time with near-zero overhead on the target workload.

Analyze

Receive a comprehensive breakdown: wall-clock time, CPU decomposition, memory forensics, page faults, I/O throughput, context switches, and more.

Export & Iterate

Push reports to files with -o, append to rolling logs with -a, or build custom dashboards with our format string templating engine.

$ chrono -o report.log -a ./deploy.sh

Performance is not a feature.
It's a first principle.

For too long, performance observability has been bolted on as an afterthought — heavyweight APM agents that consume more resources than the processes they monitor, dashboards that take longer to load than the builds they track, pricing models that punish you for actually using the product.

We built Chrono because we believe the atomic unit of performance understanding is a single execution. Every process tells a story — how much real time it consumed, how it allocated CPU cycles between user and kernel space, how it touched memory, how it interacted with the filesystem, and how the scheduler treated it. That story should be captured instantly, reported clearly, and cost nothing to observe.

This is not monitoring. This is execution intelligence.

See It In Action

Real profiles. Real output. Real clarity.

Verbose Mode `-v`

The complete picture. Every metric Chrono captures, formatted for maximum readability.

$ chrono -v node server.js --test

Command being timed: "node server.js --test"

User time (seconds): 0.42

System time (seconds): 0.08

Percent of CPU this job got: 96%

Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.52

Maximum resident set size (kbytes): 35712

Major (requiring I/O) page faults: 0

Minor (reclaiming a frame) page faults: 8847

Voluntary context switches: 23

Involuntary context switches: 5

File system inputs: 0

File system outputs: 8

Socket messages sent: 0

Socket messages received: 0

Signals delivered: 0

Page size (bytes): 4096

Exit status: 0

Custom Report Builder `-f`

Build bespoke performance reports with our proprietary format string templating engine.

$ chrono -f "\nWall: %E\nCPU: %P\nRSS: %M KB\nFault: %F maj / %R min\nI/O: %I in / %O out" \

gcc -O2 -o server main.c

Wall: 0:02.41

CPU: 98%

RSS: 127488 KB

Fault: 3 maj / 24519 min

I/O: 2048 in / 512 out

Portable Mode `-p`

Standards-compliant output format that integrates into any CI pipeline or scripting workflow.

$ chrono -p npm test

PASS src/utils.test.ts (3 suites, 47 tests)

real 2.89

user 2.61

sys 0.24

Export to File `-o` / `-a`

Redirect profiles to files or append to rolling logs. Build historical performance baselines effortlessly.

$ chrono -o perf.log -a ./build.sh

Build complete.

$ cat perf.log

0.84user 0.12system 0:01.02elapsed 94%CPU

(0avgtext+0avgdata 24320maxresident)k

512inputs+128outputs (0major+943minor)pagefaults 0swaps

Pricing

Start free. Scale when you're ready.

Every tier is built around real capabilities. Unlock more metrics as your observability needs grow.

Starter

$0/mo

Basic execution timing for individual developers.

Real/User/Sys timing only
10 profiles per month
Standard output only
POSIX portable format (-p)
Custom format strings
File export
Memory & I/O metrics

Get Started

Trusted by engineers who ship.

"We replaced our entire APM stack with Chrono. One command, 47 metrics, zero overhead. Our build pipeline performance regressions dropped by 83% in the first sprint. This is the kind of high-leverage tool that compounds over time."

Iris Park

VP of Platform Engineering, ScaleForge

"The verbose mode is a game-changer. We caught a memory leak that was invisible to every other tool we tried — a major page fault pattern that only showed up under Chrono's forensics suite. Category-defining product."

Luca Feretti

Principal SRE, DataMesh

"I've been building performance tools for a decade. Chrono's format string engine is best-in-class — I pipe custom reports directly into Grafana. It's the 10x unlock I didn't know I needed."

Mila Lindt

Solo Developer & Performance Consultant

"Context switch analytics changed how we think about scheduling at InfraPrime. Chrono surfaces voluntary vs involuntary preemptions — data that used to require kernel tracing. We shipped it to every engineer on day one."

Kai Hashimoto

CTO, InfraPrime

FAQ

Questions? Answered.

What exactly does Chrono measure? +

Chrono captures three core timing dimensions — elapsed real (wall-clock) time, user-mode CPU time, and system-mode (kernel) CPU time — plus an extensive set of resource metrics including maximum resident set size, page faults (major and minor), filesystem I/O operations, socket messages, context switches, signals delivered, and overall CPU utilization percentage.

Can I customize the output format? +

Absolutely. Chrono's format string engine (-f flag) supports over 20 format specifiers that let you build precisely the report you need. Use %E for elapsed time, %M for max RSS, %P for CPU percentage, and many more. You can also set a default format via the TIME environment variable.

Is my data secure? +

Chrono runs entirely within your process boundary. All profiling data is generated and consumed locally — nothing is transmitted externally, no telemetry is collected, and no third-party services are contacted. Your execution data never leaves your machine.

What's the difference between user time and system time? +

User time is the total CPU seconds your process spent executing in user mode — your application code, libraries, computations. System time is the CPU seconds spent in kernel mode — system calls, I/O operations, memory management. Together with elapsed time, these three metrics tell you whether your process is compute-bound, I/O-bound, or waiting on external resources.

Can I use Chrono in CI/CD pipelines? +

Chrono was built for CI. Use portable mode (-p) for machine-parseable output, export to files (-o) for artifact storage, or append to rolling logs (-a) for historical baselines. Pair with custom format strings to output exactly the metrics your pipeline needs — nothing more, nothing less.

Team

Built by engineers who obsess over performance.

David Strom

Co-founder & CEO

"Every process is a black box until you measure it. We're building the flashlight."

Karen Leung

Co-founder & CTO

"The best observability tool is the one with zero config and zero overhead. That's what we ship."

Oscar Holt

Head of Engineering

"Sub-microsecond measurement precision isn't a feature — it's a requirement. We don't ship anything less."

Execution intelligence,
zero overhead.