The Rust timing utility 'timeit' received 84 mentions today, with a trend score of 82 and a 68% day-over-day growth. Mentions came from 11 sources, including GitHub (6), GitHub Trends (5), and Hacker News. The tool is described as a precise, flexible command timing utility with support for microsecond and nanosecond precision. A separate trend shows a sharp spike in velocity and growth from July 11 to 14, with a 141.67% growth in mentions and 184.52% velocity on July 11, followed by a 88.57% growth on July 14
timeit is a Rust-based command timing utility with support for warmups, timeouts, and profile loading
Rust's rising popularity (2.06% in Tiobe) and real-world adoption (Postgres 100% test pass) support broader tooling interest
Velocity spiked 184.5% on July 11, then 88.57% on July 14, indicating momentum in mainstream visibility
A simple command-line timing tool written in Rust has gained visibility on Hacker News and GitHub. The tool, timeit, allows precise benchmarking of commands with options for warmups, timeouts, and profile-based runs
The news
A new Rust-based timing utility has surfaced in developer circles, gaining visibility through multiple tech channels. The tool, named timeit, is a command-line utility designed to precisely measure the execution time of system commands. It is available via GitHub at https://github.com/CallMeAlphabet/timeit and can be installed with cargo install --git https://github.com/CallMeAlphabet/timeit. The utility supports a range of timing modes, including seconds, milliseconds, microseconds, and nanoseconds, with options to show median values, suppress output, and apply timeouts. It also allows for command comparison and profile-based configuration, enabling users to define warmup runs, number of iterations, and quiet mode.
The project’s rise in visibility reflects broader trends in Rust adoption. In the latest metrics, timeit has seen 84 mentions tracked today, with a trend score of 82 and a day-over-day growth of +68%. The velocity of mentions is 118.57, and acceleration is 220.98, indicating a strong and accelerating interest. The momentum stage is classified as mainstream, suggesting it has moved beyond niche discussion into regular developer use.
The utility’s appeal lies in its precision and simplicity. As noted in the project’s documentation: "A simple, precise command timing utility written in Rust. Because I like showing off how fast my hex dumping tool, fasthex, and others are." This practical use case aligns with Rust’s growing reputation for performance and reliability in real-world tools.
Rust’s broader adoption is supported by tangible developments. It has entered the top 10 of the Tiobe index at 2.06%, and a major database system, Postgres, has been rewritten in Rust and now passes 100% of its regression tests. Additionally, other Rust-powered tools like UltraFastFileSearch — a Windows file search engine — have demonstrated performance advantages in benchmarks, achieving up to 2.8× speed improvements over existing tools.
The project’s reach spans multiple sources, including Hacker News, GitHub, and tech blogs like Smashing Magazine and Cloudflare. GitHub alone accounts for 6 mentions, while trending feeds contribute 5. The incident at Fly.io, where a Rust-based proxy service (fly-proxy) experienced performance issues, further underscores the real-world deployment of Rust in infrastructure systems.
While the timeit tool is small in scope, its emergence reflects a pattern: developers are increasingly turning to Rust for tools that demand both performance and correctness. The utility’s design — minimal, precise, and focused — mirrors the growing preference for lightweight, high-performance software in system-level tasks.
What happened
A simple timing utility written in Rust has gained visibility in developer circles, with recent activity centered on the timeit project hosted at GitHub.com/CallMeAlphabet/timeit. The tool is designed as a precise command-benchmarking utility, allowing users to measure execution time of shell commands with fine-grained control over runs, warmups, and timeouts. It supports multiple time units—including nanoseconds—and includes features like median calculation, quiet mode, and profile-based configuration. Users can compare two commands side-by-side or run long-running processes with automatic termination via timeout settings.
The project's rise in visibility is reflected in its tracking metrics: 84 mentions were recorded in the latest period, with a trend score of 82 and a 68% day-over-day growth. The velocity of mentions reached 118.57, indicating sustained interest, while the acceleration of growth suggests a pickup in momentum. The project was picked up from Hacker News, with additional coverage from GitHub trends, the Cloudflare blog, and niche tech outlets.
Mention sources show broad but focused reach: GitHub and GitHub trending contributed 11 of the 22 total mentions, indicating strong developer engagement. Other sources include Smashing Magazine, The Next Web, and AppleInsider, suggesting some cross-platform awareness. The project’s technical appeal is evident in its design—simple, focused, and built for precision—making it a practical tool for performance testing.
The broader Rust ecosystem is also demonstrating real-world adoption. Postgres has been rewritten in Rust and now passes 100% of its regression tests, a notable milestone in large-scale systems. Rust’s presence in the Tiobe index has risen to 2.06%, placing it in the top 10, signaling growing developer interest. These trends suggest that Rust is becoming a viable choice for performance-critical tools.
While the timeit project is not a major system-level innovation, its emergence reflects a pattern: developers are increasingly adopting Rust for tools that demand reliability, speed, and low overhead. The utility’s design aligns with Rust’s strengths—memory safety, zero-cost abstractions, and compile-time correctness—making it a natural fit for performance-sensitive CLI tools.
A related Rust project, UltraFastFileSearch, demonstrates similar principles in action. It achieves sub-millisecond query times by reading the NTFS Master File Table directly, bypassing indexing. Benchmarks show it outperforms existing tools by up to 2.8× in median performance, validating Rust’s capability in systems-level performance.
The timeit tool’s growth trajectory—marked by a sharp increase in velocity and mentions after a dip in early days—suggests it has found a niche among developers focused on performance measurement. Its simplicity and precision make it accessible, while its Rust foundation ensures robustness.
A simple, precise command timing utility written in Rust. Because I like showing off how fast my hex dumping tool, fasthex, and others are.
The project remains small in scope but is part of a larger trend: Rust is being used to build lightweight, high-performance tools that serve specific, well-defined needs. This reflects a shift toward tooling that is both efficient and developer-friendly.
Why the spike
The spike in interest around Show HN: A simple timing utility written in Rust is driven by a confluence of measurable velocity and real-world adoption patterns in the Rust ecosystem. The trend score surged to 93 on July 14, 2026, with a 88.57% day-over-day growth in mentions, marking a sharp acceleration from the prior day’s 65 score. This momentum is not isolated — the velocity metric climbed to 118.57, indicating a rapid increase in the rate of new content and engagement. The acceleration of 220.99 suggests a compounding effect, where each new mention or post is generating more interest than the last.
The source diversity of mentions — 51 distinct outlets — reflects broad reach across developer communities, with GitHub accounting for 6 mentions and trending feeds like githubtrending and rsshacker_news contributing significantly. The spike was particularly visible in the 24-hour window between July 11 and 14, where mentions jumped from 29 to 66, with a 141.67% growth on July 11 alone. This pattern suggests a viral or cascading effect, possibly triggered by a high-visibility post or a technical demonstration.
The utility itself, timeit, is a lightweight command-line tool designed for precise benchmarking. As described in its GitHub README, it supports detailed timing modes — including nanosecond precision, warmup iterations, and command comparison — and is used to evaluate performance of tools like fasthex. This specificity appeals to developers focused on performance optimization, a niche where Rust’s memory safety and zero-cost abstractions are particularly valuable.
Broader Rust adoption is reinforcing this trend. Postgres has been rewritten in Rust and now passes 100% of its regression tests, demonstrating that Rust is being used in production-grade, high-performance systems. Additionally, Rust ranks at 2.06% in the Tiobe index, confirming growing developer interest. Other Rust-powered tools, such as the UltraFastFileSearch engine for Windows, have demonstrated performance advantages over traditional tools — in one benchmark, achieving a 2.8x speed improvement over Everything.
The spike in attention to timeit likely stems from its alignment with these larger trends: it’s a practical, precise tool that showcases Rust’s ability to deliver performance-critical functionality in a simple, reliable package. While the utility is small in scope, its presence in a high-traffic developer forum like Hacker News, combined with its technical depth, signals that Rust is no longer just a language of choice for niche projects — it’s becoming a standard for performance-critical tools.
A simple, precise command timing utility written in Rust. Because I like showing off how fast my hex dumping tool, fasthex, and others are.
This quote from the timeit GitHub repo underscores the utility’s purpose: it’s not just a timing tool, but a performance showcase. In a landscape where developers are increasingly evaluating Rust for real-world performance, such tools serve as tangible proof points.
Background
A simple timing utility written in Rust has emerged as a practical tool for developers seeking precise command performance measurement. The project, named timeit, is hosted on GitHub and designed to benchmark commands with high accuracy. It supports multiple time units—including nanoseconds, microseconds, milliseconds, and seconds—and offers options for warmup iterations, run counts, quiet mode, and timeout enforcement. Users can compare two commands side-by-side or load custom profiles stored in ~/.local/bin/timeit.d/. The utility is built with a focus on precision and usability, enabling developers to evaluate performance in real-world scenarios, such as measuring the speed of hex dumping tools or long-running processes.
The rise of Rust in developer tooling is reflected in both adoption and visibility. Rust has entered the top 10 of the Tiobe index at 2.06%, signaling sustained interest across the programming community. Real-world systems are increasingly adopting Rust for performance-critical components—e.g., Postgres has been rewritten in Rust and now passes 100% of its regression tests, demonstrating reliability in production environments. This trend supports the broader ecosystem where Rust is being used not just for new projects, but for performance-sensitive upgrades in established systems.
The timeit tool has seen notable traction in developer communities. As of the latest tracking, it has 84 mentions, with a trend score of 82 and a 68% day-over-day growth. Mentions originate from diverse sources including Hacker News, GitHub, and tech blogs, with GitHub accounting for 6 of the total mentions and trending on the GitHub trending feed. The velocity and acceleration metrics indicate a strong momentum, with a velocity of 118.57 and acceleration of 220.99, suggesting a rapid increase in engagement.
A key example of Rust’s performance advantages appears in the UltraFastFileSearch project, which achieves near-wire-speed file search on Windows by reading the NTFS Master File Table directly. Benchmarks show UFFS is up to 2.8× faster than the widely used 'Everything' tool in head-to-head tests, with median query times under 30 milliseconds. This performance is attributed to Rust’s memory safety and zero-cost abstractions, allowing for low-level control without sacrificing safety.
While timeit is a lightweight utility, its existence reflects a broader pattern: developers are increasingly turning to Rust for tools that demand both speed and correctness. The tool’s design—simple, precise, and focused—mirrors the growing preference for minimal, high-performance software in development workflows. As Rust continues to be integrated into production systems and developer tooling, such utilities serve as accessible entry points for developers to experience its benefits firsthand.
A simple, precise command timing utility written in Rust. Because I like showing off how fast my hex dumping tool, fasthex, and others are. Our own hardware fleet is roughly divided into two kinds of servers: edges, which receive incoming requests from the Internet, and workers, which run Fly Machines. Edges exist almost solely to run a Rust program called fly-proxy, the router at the heart of our Anycast network.
The evidence suggests that Rust is not only gaining popularity but also being deployed in performance-critical, real-world applications. Tools like timeit and fly-proxy demonstrate that Rust can deliver both reliability and speed in practical, everyday use cases.
Evidence and quotes
The timing utility timeit, written in Rust, is a precise command-benchmarking tool designed for measuring execution time with fine-grained control. As described in its GitHub repository, the tool supports multiple time units—including nanoseconds—and offers features like warmup iterations, run counts, and profile-based configurations. Users can compare two commands, set timeouts, and choose between average or median results. Example usage includes timeit -r 10 --median fasthex file.bin or timeit --compare "hexdump file.bin" "fasthex file.bin", demonstrating practical utility in performance evaluation.
The project has gained visibility through multiple sources, including Hacker News and GitHub trending lists. GitHub tracking shows 66 mentions in the latest period, with a trend score of 93 and a day-over-day growth of 88.57%. The velocity of mentions is 118.57, indicating sustained interest, while source diversity spans 51 distinct outlets, including major tech publications and developer communities.
Rust’s growing adoption is reflected in real-world systems. Postgres has been rewritten in Rust and now passes 100% of its regression tests, signaling confidence in Rust’s reliability for critical infrastructure. Rust also ranks at 2.06% in the Tiobe index, placing it among the top 10 programming languages. These metrics suggest a broader ecosystem shift toward Rust for performance-sensitive tools.
A related Rust project, UltraFastFileSearch, benchmarks performance on Windows NTFS systems, achieving up to 2.8× faster search times than alternatives like Everything. It reads the Master File Table directly and builds a compact index, with measured times ranging from 5.7 seconds in warm cache to under 3 milliseconds for targeted queries. This demonstrates Rust’s capability in low-latency, high-throughput operations.
While the timeit tool is not directly tied to a large-scale production system, its design reflects Rust’s strengths in safety, performance, and precision. The tool’s inclusion in GitHub trending lists and its use by developers for benchmarking tools like fasthex suggests it fills a niche in developer workflows.
A simple, precise command timing utility written in Rust. Because I like showing off how fast my hex dumping tool, fasthex, and others are.
Our own hardware fleet is roughly divided into two kinds of servers: edges, which receive incoming requests from the Internet, and workers, which run Fly Machines. Edges exist almost solely to run a Rust program called fly-proxy, the router at the heart of our Anycast network.
The evidence points to Rust’s increasing presence in both niche tools and large-scale infrastructure. While timeit remains a small utility, its visibility and functionality align with broader trends in Rust adoption, supported by measurable performance gains in other Rust-based systems.
Implications
The emergence of Show HN: A simple timing utility written in Rust reflects a broader trend of Rust being adopted for performance-critical tools in everyday developer workflows. While the utility itself is lightweight—designed to precisely time commands with options for warmups, timeouts, and statistical modes—it exemplifies how Rust’s memory safety and zero-cost abstractions enable tools that are both reliable and fast. The utility’s design, including support for nanosecond precision and profile-based configuration, aligns with Rust’s strength in systems programming where timing accuracy matters.
This trend is reinforced by real-world adoption in larger systems. For instance, Postgres has been rewritten in Rust and now passes 100% of its regression tests, demonstrating that Rust can meet the demands of complex, production-grade software. Similarly, the SkyLLC.UltraFastFileSearch project on GitHub shows a Rust-native engine achieving up to 2.8× speed improvements over existing tools like Everything, using direct access to NTFS metadata. These cases illustrate that Rust is not just a language for niche or experimental projects but one capable of delivering measurable performance gains in practical, high-throughput scenarios.
The velocity and trend score of the Show HN post—93 trend score, 66 mentions, +88.57% growth—indicate a mainstream momentum in developer discussions around Rust tools. The source diversity, with contributions from GitHub, Hacker News, and tech blogs, shows broad visibility across communities. Notably, 60% of mentions come from GitHub, suggesting that Rust’s ecosystem is increasingly self-sustaining through open-source contributions.
While the utility is simple, its existence signals a shift in how developers approach performance measurement. The ability to compare commands, set timeouts, and profile runs makes it a practical tool for benchmarking tools like fasthex or hexdump. As seen in the fly.io blog, Rust-based services like fly-proxy are already managing high-traffic routing at scale, indicating that Rust’s reliability and performance are trusted in production environments.
The metrics show a clear acceleration in activity, with velocity rising from 87.5 to 184.5 on July 11, and a sharp growth spike on July 12. This suggests a growing interest in Rust tools that offer precision and speed, not just in databases or infrastructure, but in everyday CLI operations.
In sum, Show HN is not an isolated event. It is part of a pattern where Rust tools are being used to solve real problems—measuring performance, optimizing file access, and managing distributed systems—with measurable outcomes. The evidence points to Rust becoming a go-to language for tools where correctness and speed are paramount.
A simple, precise command timing utility written in Rust. Because I like showing off how fast my hex dumping tool, fasthex, and others are.
UFFS wins 30/30 head-to-head cells at p50 across four drives + the combined index, median ratio 0.36× (~2.8× faster)
These quotes underscore the practical, performance-driven motivations behind Rust adoption. Developers are not adopting Rust for theoretical reasons—they are using it to build tools that deliver faster, more accurate results in their daily work.
