Rust Shined Over Python for My CLI Tool

When building automation tooling, language selection often revolves around performance characteristics or developer familiarity. However, a recent CLI tool rewrite from Python to Rust revealed a more nuanced calculus, where reliability, distribution, and developer experience ultimately tipped the scales in an unexpected direction.

The context involves a data processing and uploading tool centered around command-line operations. The tool's primary functions involved data conversion, standardization, and API interactions—tasks where Python's performance characteristics would typically be considered adequate, given that most operations were network-bound rather than CPU-intensive. Yet, the author found compelling reasons to migrate to Rust despite this context.

The primary motivation stemmed from a desire for enhanced reliability and robustness. While Python has made significant strides in tooling with uv, Ruff, and Typo, and offers excellent type hinting through Pydantic, the author found that complexity inevitably emerged throughout the application. Managing invariants across the codebase became increasingly challenging, and Python's exception handling, while functional, lacked the explicitness that became valuable when careful error recovery was essential.

Rust's Result and Option enums provided a more structured approach to error handling. Although potentially verbose, this explicit error model offered clarity about how functions might fail, reducing the cognitive load on developers and minimizing the need for extensive try-except blocks throughout the codebase. The type system's strictness enforced certain invariants at compile time, rather than relying on runtime checks or extensive testing to catch potential issues.

Testing presented another interesting contrast. Initially, the author anticipated Python would have an advantage due to its mature mocking ecosystem. However, Rust's trait system enabled a cleaner approach to test isolation. By defining traits like HttpGet rather than directly implementing functionality, the author could create mock implementations for testing without resorting to runtime import mocking or monkey-patching—techniques that had previously caused issues in the Python implementation.

The quantitative results were striking. The Python implementation required approximately 12 weeks of development time (plus additional feature requests) and accumulated 23,598 lines of code including tests (11,166 without tests). In contrast, the Rust rewrite took only one week and resulted in 20,055 lines of code including test blocks (14,946 without tests). This dramatic reduction in development time, despite the initial Python implementation providing valuable domain knowledge, speaks to Rust's potential for increasing developer productivity in certain contexts.

Distribution benefits emerged as another significant advantage. The Python tool required users to clone repositories, set up environments with uv, or access private Docker images with specific artifactory tokens. Rust enabled cross-compilation to multiple platforms (ARM 64 macOS, Windows x86, and Linux), allowing users to download precompiled binaries directly. This simplified deployment process reduced friction for end users and eliminated dependency management complexities.

The startup experience also improved noticeably. While not a primary motivator given the network-bound nature of the operations, the immediate responsiveness of the Rust binary provided a qualitatively better user experience. The crispness of the tool's execution contributed to an overall impression of robustness and reliability.

These findings challenge conventional wisdom about language selection for CLI tools. When the primary operations are I/O-bound rather than CPU-intensive, the performance advantages of Rust might seem less compelling. However, the benefits in terms of error handling safety, testing clarity, distribution simplicity, and user experience create a compelling case that extends beyond raw performance metrics.

The author acknowledges Python's strengths, including its excellent tooling ecosystem, readability, and AI tool compatibility. For many applications, Python remains an excellent choice. Yet this experience suggests that for certain types of automation tooling—particularly those requiring reliability, careful error handling, and straightforward distribution—Rust may offer advantages that transcend traditional performance considerations.

The rewrite story serves as a reminder that language selection involves multiple dimensions beyond raw speed. Developer experience, maintainability, distribution challenges, and user experience all contribute to the long-term success of software projects. In this case, Rust provided a more holistic solution, delivering reliability and simplicity that the Python implementation, despite its merits, could not match.