Research: Rust rewrite feasibility facts

Question

What facts does the Rust-rewrite go/no-go decision need? Surface, from primary sources:

Ecosystem fit: crates covering devlaunch's surface — CLI parsing with shell completions (clap/clap_complete), fuzzy selection (skim or embedding fzf), subprocess orchestration of devpod/git, TOML/JSON config-state handling.
Distribution: what a Rust binary buys over the current PyPI + conda pair (single static binary, cargo-binstall, conda packaging of Rust binaries via rattler-build), and what it costs (losing pip install devlaunch?).
Effort signal: devlaunch is ~2.2K LOC of Python that is mostly subprocess plumbing plus a completion cache — what's the realistic port scope, and which parts (bash completion script, worktree metadata) carry over unchanged?
Prior art: comparable Python→Rust CLI rewrites of devtool wrappers and what they reported.

This ticket surfaces facts only; the decision itself is [the go/no-go grilling ticket].

Resolved — findings in docs/research/rust-rewrite-feasibility.md (branch research/rust-rewrite-feasibility). Every claim cites its primary source. Key facts:

Ecosystem fit

All needed crates exist and are maintained: clap/clap_complete, skim 5.6.1 (30+ releases 2025–26, usable as a library), std::process::Command maps 1:1 onto the current list-form subprocess.run calls (only gap: no built-in timeout), toml 1.1.4 + serde_json 1.0.151 give tomli/tomli_w/json parity.
clap_complete's dynamic completion is still behind unstable-dynamic with an open tracking issue (Stablize Rust-Native Completion Engine Tracking Issue clap-rs/clap#3166) and known bash bugs — but this is moot: devlaunch's 158-line bash completion never invokes the binary (it sources the cached completions.bash), so the script, cache format, and ~3ms hot path carry over unchanged.

Distribution

Gains: single static binary (no Python prerequisite), cargo-binstall + GitHub-release binaries, cargo-dist automation.
Conda: rattler-build has an official Rust tutorial (cargo install --locked --bins --root ${PREFIX}, ${{ compiler('rust') }}); the existing rattler-build-action → prefix.dev pipeline stays, but the recipe goes from noarch: python to per-platform compiled builds.
PyPI is not lost: maturin bin bindings ship a Rust binary as a wheel — exactly how uv and prek publish to PyPI. Cost is a per-platform wheel matrix instead of one hatchling noarch wheel.

Effort signal (~2.6K LOC Python)

Ports ~1:1: all subprocess plumbing, spec-parsing regexes, JSON cache, TOML config, serde-shaped dataclasses, and the entire bash completion script (byte-identical).
Needs redesign: hand-rolled argv dispatch, iterfzf→skim (or spawn fzf), self-respawn via current_exe(), and Result-based error plumbing.
The dominant cost is the test harness: 413 tests lean on mock/monkeypatch at subprocess seams, which don't port — they'd be rebuilt as trait seams or PATH-shim fake binaries. Their durable value is as a behavior spec (exact devpod arg sequences, ID sanitization, cache formats); the docker/e2e suites carry over as acceptance tests.

Prior art

prek (Rust rewrite of pre-commit — closest analogue): single binary, no Python runtime, faster + less disk, adopted by CPython/FastAPI/Airflow, and it kept PyPI/conda/cargo/npm/installers simultaneously.
uv (8–10x cold / 80–115x warm vs pip) and ruff (10–100x) got their gains from replacing CPU-bound Python work — devlaunch's latency lives in devpod/git child processes, so those speedups don't transfer; the transferable wins are prek's (startup, runtime-free distribution).

Decision belongs to #53.