poly
Early prototype · open source

One runtime. Two ecosystems.

Run TypeScript or Python. Import across both ecosystems. Build and ship one executable.

Try the prototype Explore the code 
// target API
import { add } from "./math.py"
  with { type: "python" };

console.log(add(20, 22)); // 42
def add(left, right):
    return left + right
$ poly run main.ts 42
01executable
01OS process
02language ecosystems
00sidecar processes

One project, two ecosystems

Run either.
Import both.
Ship one.

Poly is building a unified module graph, dependency workflow, and release path around Bun and RustPython—without turning either language into a separate service.

01 / Runtime

Both languages are entry points

Run a TypeScript application or a Python tool through the same executable and the same project configuration.

poly run app.ts · poly run tool.py
02 / Modules

Python files are modules, not services

The target module system makes cross-language imports explicit, analyzable, and native to the project.

import { add } from "./math.py" with { type: "python" }
03 / Dependencies

Keep Bun. Keep uv.

npm packages stay in Bun's ecosystem. Python packages stay locked by uv, with Poly checking what RustPython can actually run.

poly sync
04 / Distribution

One application artifact

The roadmap combines both module graphs, their dependencies, and project resources into one platform-native executable.

poly build app.ts

One executable. One process.

Two runtimes, one Rust host.

The M0 prototype embeds RustPython directly into a pinned Bun source tree. Its small synchronous bridge proves the architecture before the higher-level module system is built.

  • Bun runs JavaScript and TypeScript
  • RustPython runs Python with a frozen standard library
  • No subprocess, sidecar, socket, or stdio RPC
  • Clear path from JSON calls to imports and object proxies
Bun / JavaScriptCore JS / TS
native host call
Rust host Poly
direct call
RustPython Python
one process boundary

Project status

Working foundation.
Product ahead.

Poly is an engineering prototype. The source integration and core bridge exist today; the module system, dependency workflow, and standalone application builder remain active work.

Bun + RustPython source integration Implemented
TypeScript and Python entry-point routing Validating
RustPython JSON call bridge Core tested
Cross-language imports and callable proxies Planned
Bun + uv dependency workflow Planned
Standalone application build Planned

Try the current prototype

Build Poly from source.

The current build follows Bun's native toolchain requirements and may take time on a clean machine. Start with the repository guide for exact prerequisites and verified boundaries. 

$ git clone https://github.com/liooil/poly
$ cd poly
$ pwsh ./scripts/bootstrap-bun.ps1 -Configuration Release
Source code ↗ Technical design ↗ Roadmap ↗