Migrate To Rust
GoogleOfficialPublished by Google
- Skill
- Workflow
- Software development
- Apache-2.0
- Low risk
- Has scripts
AutoGineer summary
Written by AutoGineer from the skill’s own files, not by the author
This skill provides a comprehensive, multi-stage process for porting legacy codebases written in languages like C++, Fortran, Java, or Python into modern, memory-safe Rust. It emphasizes a rigorous engineering approach, requiring the use of specific telemetry scripts to track progress, performance benchmarks, and test coverage. The workflow includes architectural planning, iterative refactoring, A/B parity testing, and Profile-Guided Optimization (PGO) to ensure the resulting Rust implementation is both safe and performant. It concludes by generating a detailed, first-person engineering narrative and an interactive HTML infographic to visualize the migration journey.
What it does
- Analyzes legacy codebases to identify technical debt and architectural opportunities.
- Scaffolds a Rust workspace with strict memory safety requirements.
- Performs iterative refactoring with automated test-driven self-healing.
- Validates output parity between legacy and new implementations using deterministic seeds.
- Optimizes performance through data-oriented design and LLVM Profile-Guided Optimization.
- Generates telemetry reports and interactive infographics documenting the migration metrics.
When to use it
- When migrating a legacy GitHub repository or local codebase to Rust.
- When porting complex C++, Fortran, Python, or Java workloads to memory-safe Rust.
- When designing high-performance Struct-of-Arrays or SIMD architectures in Rust.
- When optimizing Rust ports using LLVM Profile-Guided Optimization.
Advantages
- Ensures 100% memory safety by forbidding unsafe code blocks.
- Provides quantified performance improvements across four distinct optimization stages.
- Maintains high code quality through strict file size and documentation standards.
- Delivers transparent, data-backed reporting on the migration process and outcomes.
Usage examples
- “Migrate the legacy C++ codebase located at /local/path/to/project to Rust.”
- The agent initializes the telemetry ledger, scans the legacy project, benchmarks the baseline, and begins the multi-stage migration process.
- “Port my Python data processing library to a high-performance Rust implementation.”
- The agent audits the Python code, scaffolds a Rust workspace, implements the core logic, and verifies parity before applying PGO.
Install
Download the skill as a ZIP:
https://autogineer.com/agent-skills/google/migrate-to-rust/downloadUnzip it into the cross-client skills folder of your project:
mkdir -p .agents/skills && unzip migrate-to-rust.zip -d .agents/skills
Documentation by Google
Migrate Legacy Codebases to Safe Rust
Act as a Systems Architect, Performance Engineer, and Rust Specialist. Your goal
is to migrate legacy codebases into 100% Safe, PGO-tuned Rust while recording
measured telemetry and a first-person engineering narrative via
scripts/telemetry.py.
Execution Contract & Portability
When migrating a repository or local directory ({github_url} or
{codebase_path}), follow these execution rules across agentic harnesses:
Stage 0 External Code Confirmation Gate: After cloning an external repository and inspecting its build files, present the resolved legacy build command, run command, and target directory to the user and obtain confirmation before compiling or executing cloned code. (For local code that the user explicitly instructed you to run, or once Stage 0 confirmation is granted, proceed directly.)
Continuous Stage 1 -> Stage 2 Progression: Once Stage 0 baseline capture is complete, proceed directly from writing the Architectural Blueprint (Stage 1) into implementing and verifying the Rust workspace (Stage 2) without pausing between milestones, where the host environment permits autonomous tool execution.
Bounded Automated Self-Healing (Max 5 Iterations): When tests,
clippylints, or A/B parity checks fail, log the failure viascripts/telemetry.py, diagnose and fix the root cause, and re-test automatically up to a budget of 5 self-healing iterations (or 15 minutes per phase). If any test or seed still diverges after the budget is exhausted, record the partial state inmigration_telemetry.jsonand document the remaining gap in the final report rather than looping indefinitely.Verification Targets & Definition of Done:
#![forbid(unsafe_code)]Rust crate compiles with a target of0cargo clippywarnings (any unavoidable exception must be documented).Unit, integration, doc, and property-based (
proptest) tests pass with a target of>= 95%branch coverage (any unavoidable exception must be documented), with every run logged inmigration_telemetry.json.A/B differential output parity is verified across
Ndeterministic seeds within a documented numerical epsilon (--max-abs-error), with any floating-point/FMA/PRNG divergence root-caused and logged.All 4 benchmark stages (
legacy_baseline,safe_rust,soa_simd,pgo_lto) are measured and logged (or omitted cleanly if a tool such asllvm-profdatais unavailable).The interactive HTML infographic (
migration_infographic.html) is rendered viascripts/telemetry.py render-infographic.
End-to-End Workflow Checklist
Copy this checklist to track progress across the three stages (detailed command recipes and architectural specifications are in references/pgo_and_telemetry_guide.md):
- [ ] Stage 0: Acquire repo, initialize `migration_telemetry.json` (`discovery` bucket), scan legacy codebase, confirm resolved build/run commands, and benchmark baseline
- [ ] Stage 1: Audit legacy code (`blueprint` bucket), log opportunities & latent legacy bugs, and generate 6-section Architectural Blueprint
- [ ] Stage 2.1: Scaffold `#![forbid(unsafe_code)]` Rust workspace & deterministic PRNG parity layer (`rewrite` bucket)
- [ ] Stage 2.2: Implement core domain types & SoA/SIMD kernels (<= 400 LOC/file target, full rustdoc) & benchmark `safe_rust` + `soa_simd`
- [ ] Stage 2.3: Run Verification Crucible (`test_heal` bucket, max 5 iterations) — log initial test failure % and each self-healing fix
- [ ] Stage 2.4: Run A/B differential parity harness (`parity` bucket, max 5 iterations) across N seeds within documented epsilon tolerance
- [ ] Stage 2.5: Run LLVM Profile-Guided Optimization (`pgo_bench` bucket), scan final Rust codebase, and render `migration_infographic.html`Stage 0: Repository Acquisition, Telemetry Init & Legacy Baseline
Resolve context parameters from the repository or directory:
| Parameter | Placeholder | Resolution Strategy |
|---|---|---|
| Source Input | {codebase_path} or {github_url} | Accept a GitHub URL (https://github.com/...) or a local filesystem path |
| Original Language / Framework | {legacy_language} | Auto-detect from file extensions and build files (CMakeLists.txt, Makefile, meson.build, pyproject.toml, pom.xml, *.f90, *.cpp) |
| Baseline Run Command | {baseline_run_command} | Identify from README.md, CI workflows (.github/workflows/*.yml), Makefile, or test scripts |
| Telemetry Ledger | {workspace_dir}/migration_telemetry.json | Initialized via scripts/telemetry.py init at the start of Stage 0 |
Stage 0 Execution Steps
Clone Repository (if GitHub URL): Choose a clean local directory (default to
~/rust_migrations/{repo_name}, or inside the current workspace if requested) and rungit clone {github_url} ~/rust_migrations/{repo_name}.Initialize Telemetry & Scan Legacy Codebase: Run
scripts/telemetry.py init --telemetry "{workspace_dir}/migration_telemetry.json" --project-name "{project_name}" --legacy-lang "{legacy_language}". Start thediscoverybucket and runscripts/telemetry.py scan-codebase --phase beforeon the legacy source directory to record baseline file count, code LOC, comment density %, max file LOC, nesting depth, average function length, and raw pointer/memory hazards.Confirm & Benchmark Legacy Baseline: Before executing build or run commands from a cloned external repository, surface the resolved build command,
{baseline_run_command}, and working directory for user confirmation. Once confirmed, compile the legacy project in release mode (-O3/Release), capture golden reference outputs across deterministic seeds, measure baseline wall-clock runtime (ms) and peak RSS (MB), and log Stage 1 viascripts/telemetry.py log-benchmark --stage legacy_baseline.
Stage 1: Deep Audit, Opportunity Discovery & Architectural Blueprint
Start the blueprint timer bucket (scripts/telemetry.py start-bucket --bucket blueprint), inspect the repository, log every discovered opportunity and
latent legacy bug (scripts/telemetry.py log-opportunity), and generate the
6-section Markdown blueprint defined in Section 2 of
references/pgo_and_telemetry_guide.md.
Stage 1 -> Stage 2 Transition: Save the blueprint and proceed directly to Stage 2 (unless the user explicitly requested a blueprint-only plan).
Stage 2: Phased Safe Rust Implementation, Self-Healing, PGO & Infographic
Follow the command recipes and core engineering standards in references/pgo_and_telemetry_guide.md for each step:
Step 1: Scaffold Safe Rust Workspace & Port Modules (rewrite Bucket)
Start the
rewritetimer bucket (scripts/telemetry.py start-bucket --bucket rewrite).Initialize the Rust workspace with
#![forbid(unsafe_code)]insrc/lib.rsandsrc/main.rs.Implement the deterministic PRNG wrapper, domain types, and modules in dependency order (
<= 400LOC per file target, complete//!and///rustdoc with runnable doc-tests).Benchmark and log Stage 2 (
safe_rust) and Stage 3 (soa_simd) viascripts/telemetry.py log-benchmark.
Step 2: The Verification Crucible — Test, Fail, Diagnose & Fix (test_heal Bucket)
Start the
test_healtimer bucket (scripts/telemetry.py start-bucket --bucket test_heal).Write unit tests, runnable doc-tests, and
proptestboundary tests.Run
cargo test --all-targets,cargo test --doc, andcargo clippy --all-targets.Log Every Iteration (Up to 5 Iterations): After Run 1 and each subsequent run, invoke
scripts/telemetry.py log-test-runwith total tests, passed, failed, coverage %, clippy warnings, diagnostic summary, and fix applied. Iterate until0failures and0warnings (or until the 5-iteration budget is reached, documenting any unavoidable exception).
Step 3: A/B Differential Output Parity (parity Bucket)
Start the
paritytimer bucket (scripts/telemetry.py start-bucket --bucket parity).Run the automated A/B differential harness across
Ndeterministic seeds comparing{baseline_run_command}and the Rust binary within the documented epsilon tolerance.Log each parity iteration via
scripts/telemetry.py log-parity-run. If any seed diverges beyond epsilon, bisect the first diverging step, repair the discrepancy, and re-run (up to 5 iterations).
Step 4: Profile-Guided Optimization (PGO) & Final Benchmarks (pgo_bench Bucket)
Start the
pgo_benchtimer bucket (scripts/telemetry.py start-bucket --bucket pgo_bench).Execute the LLVM PGO workflow in references/pgo_and_telemetry_guide.md: build with
RUSTFLAGS="-Cprofile-generate=./pgo-data", run representative workloads, merge profiles viallvm-profdata, and rebuild withRUSTFLAGS="-Cprofile-use=./pgo-data/merged.profdata"andlto = "fat"(or use the documented-Ctarget-cpu=nativefallback ifllvm-profdatais unavailable).Verify that tests and A/B parity still pass on the PGO binary, then measure wall-clock runtime and peak RSS and log Stage 4 (
pgo_lto) viascripts/telemetry.py log-benchmark --stage pgo_lto.
Step 5: Final Census, First-Person AI Story & Visual Infographic
Run
scripts/telemetry.py scan-codebase --phase afteronsrc/to capture final LOC,<= 400LOC compliance, comment/rustdoc density, runnable doc-tests, nesting depth, andunsafeblock count.Log a Before vs. After Code Spotlight (
scripts/telemetry.py log-spotlight) and populate the First-Person AI Story Chapters (scripts/telemetry.py set-story).End the
pgo_benchtimer bucket and render the interactive HTML infographic (where{skill_dir}is the directory containing thisSKILL.md):python3 "{skill_dir}/scripts/telemetry.py" render-infographic \ --telemetry "{workspace_dir}/migration_telemetry.json" \ --out "{output_dir}/migration_infographic.html" \ --scope-summary "{short_summary_of_ported_modules}"Output a concise executive summary referencing the generated
migration_infographic.htmlreport and key measured before/after metrics.
Bundled Resources
Telemetry & Infographic CLI:
scripts/telemetry.pyEngineering Standards, Blueprint Spec, PGO & Telemetry Recipes: references/pgo_and_telemetry_guide.md
Interactive HTML Infographic Template: references/infographic_template.html
Files
- ATTRIBUTION.mdAdded by AutoGineer853 B
- LICENSELicence file added by AutoGineer11.1 KiB
- SKILL.md12.2 KiB
- references/infographic_template.html61.6 KiB
- references/pgo_and_telemetry_guide.md17.3 KiB
- scripts/telemetry.pyScript41.4 KiB
LICENSE
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Requirements and compatibility
Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta
“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.
Needs: Needs Python
Security
What our scanner noticed· Low risk
- Scripts that your agent may run
This skill includes scripts that your agent may run. Read them before you use it.
A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.
Attribution and licence
- Published by
- Publisher
- Google (Official)
- Source
- google/skills · skills/developers/migrate-to-rust · commit 2194d3b
- Licence
- Apache License 2.0 (redistribution allowed)
- LICENSE (added by AutoGineer from LICENSE)
- ATTRIBUTION.md (written by AutoGineer)
- Synced
AutoGineer is not affiliated with or endorsed by Google or Google.
Download ZIP
The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download migrate-to-rust.zip