py2many

py2many: Transpile Python to Multiple Programming Languages

py2many translates Python into languages including Rust, C++, Go, and Julia, with type inference to help bridge Python code to statically typed targets. It suits developers prototyping in Python who want to explore or build for other language ecosystems.

View on GitHub Compare
Stars
1.3k
Forks
89
Stars, last 30 days
+10
Last commit
2 days ago
Contributors
18

Our take

Activeregular commits and releases

Health score

56/100

How it is scored
Activity
51
Community
56
Issues
50
Pull requests
67

+10 stars in the last 30 days

py2many is an actively maintained, multi-target transpiler worth evaluating for Python-to-native workflows, provided you verify the generated code and the maturity of your chosen backend.

Good fit if

  • You want to experiment with translating Python into Rust, C++, or one of the other supported languages.
  • Your team can review and test generated code, particularly for beta or experimental targets.
  • You want an MIT-licensed project with recent commits and releases and contributions from multiple people.

Look elsewhere if

  • You need every listed target to offer the same level of maturity, since the README distinguishes production-ready, beta, and experimental support.
  • You need a turnkey migration that does not require validating transpiled output.
  • Your environment cannot provide Python 3.10 or newer, which the project configuration requires.
All health signals
Last commit2026-10-07 (2 days ago)
Commits, last 90 days39
Releases, last 12 months1 (latest v0.9, 2026-08-04)
Contributors18 (top contributor: 53% of commits)
Issues closed, last 90 days5 (typically closed in 8 days)
Pull requests merged, last 90 days17 (typically merged in 0 days)
Project age5 years

Checked on 2026-10-10 with the GitHub API.

Project history

Daily GitHub snapshots since Oct 7, 2026. History covers stars and forks; health signals are not tracked historically.

Selected snapshot

Stars

1,347

Forks

92

Change since Nov 16, 2026: 0 stars·0 forks

Overview

py2many is a transpiler that converts Python source code into several other languages. It aims to let developers start with Python and produce code for systems programming, native applications, and other language ecosystems without manually rewriting every implementation.

Support varies by target: Rust is the project's primary focus, C++ is described as production ready, and several other targets range from beta to experimental. Treat generated code as a starting point to inspect and test, especially when targeting a less mature backend.

Key Features

  • Translates Python into Rust, C++, Go, Zig, Julia, Nim, Dart, Kotlin, D, and other targets.
  • Infers types and maps them to target-language types.
  • Can emit Python code with inferred type annotations and syntax improvements.
  • Includes target-specific options through a command-line interface.
  • Provides example inputs and expected transpiled outputs in the repository's test suite.
  • Supports different maturity levels across language backends, with Rust as the primary focus.

Use Cases

  • Python developers can prototype an algorithm, then generate Rust or C++ as a basis for a native implementation.
  • Systems programmers can evaluate whether Python-authored logic can be carried into a statically typed codebase.
  • Educators and learners can compare a Python example with its generated counterpart when studying another language.
  • Teams maintaining shared library logic can investigate transpilation as a way to produce starting points for multiple target ecosystems.

What you need

Detected in the repository

  • Python >=3.10 (from pyproject.toml)
  • A test suite and automated checks on GitHub Actions

License in plain words

MITpermissive

  • Commercial use: yes
  • Modify and redistribute: yes
  • You must keep: the copyright and license notice
  • Share your changes: no

A summary, not legal advice: the LICENSE file is what applies.

Getting Started

Install and run the CLI with uvx:

uvx py2many --rust tests/cases/fib.py

See the README for installation options, target flags, and examples.

Considerations

Backend maturity is uneven: Rust is the primary focus, C++ is described as production ready, and Zig and Mojo are experimental, with limited feature coverage. The project is active, with regular commits and a recent release; contributions are not concentrated in a single person. However, issue closure activity has been modest in the measured period, so teams should assess whether their target-language needs are covered and test representative code before adopting it. The project requires Python 3.10 or newer, and the README does not claim complete compatibility with all Python programs or language features.

Found this useful?

Share it with someone who would like py2many.