Polyester

Polyester makes it possible to use R from Python by running R in a background process and communicating through a lightweight message protocol.

The goal is simplicity and reliability — especially on Windows — while keeping the design extensible to other languages in the future.

Quick Example

from polyester import RInterpreter

# Start an R interpreter
R = RInterpreter(path=r"C:\Program Files\R\R-4.5.2\bin\Rscript.exe")

# Access an R module (namespace)
base_r = R.module("base")

# Simple calculations (both return a RemoteRObject)
x = R.eval("sin(100)")
y = base_r.cos(100)

# Get results in python
print(x.fetch(), y.fetch())

# Bring a dataframe from R to Python (pd.DataFrame)
iris_df = R.eval("iris").fetch('pandas')
print(iris_df.head())

# Print head without first fetching to python
R.print(R.eval("head(iris)"))

Core Concepts

Polyester revolves around a single concept: an interpreter.

An interpreter manages:

• A background R process
• A private remote environment
• Communication over JSON Lines
• Data exchange using Apache Arrow

Interpreter API

An interpreter supports the following operations:

RemoteObject vs RemoteName

• RemoteObject A concrete object that exists in the remote R environment. Automatically cleaned up when the Python object is deleted.

• RemoteName A lazy reference to a symbol or expression in R. It may or may not exist until evaluated.

Example:

R.objects.x = 10
result = R.get(R.objects.x)   # 10

# This can also be written the following way
result = R.objects.x.fetch()   # 10

Data Exchange

DataFrames are transferred using Apache Arrow files for efficiency.

You can request a specific backend when retrieving:

df = iris_rdf.fetch("pandas")

If no df_backend is provided, polars will be used.

Important Notes

⚠ Do not print to stdout from R.

Polyester uses stdout for protocol communication. Printing to stdout() inside R will corrupt the communication channel.

If you need logging inside R, use:

message("debug info")

or write to stderr().

In python, R.print can be used to print a remote object.

Why Not Use rpy2?

rpy2 is a mature and powerful solution.

However:

• rpy2 is currently difficult to use on Windows in many environments.
• Polyester runs R as a subprocess and avoids tight binary coupling.
• The architecture is language-agnostic and may support additional languages (e.g., Julia) in the future.

If rpy2 becomes reliably usable in all target environments, Polyester may optionally integrate with it.

Design Goals

• ✅ Windows support
• ✅ Minimal external dependencies
• ✅ Simple, explicit API
• ✅ Subprocess isolation
• 🔄 Possible future multi-language support

Performance is important, but clarity and robustness are higher priorities at this stage.

Implementation Details

• R is started as a background subprocess.
• Communication happens over JSON Lines.
• DataFrames are exchanged via Apache Arrow files.
• Remote objects are reference-tracked and cleaned up automatically.

Status

Completed

• Start R subprocess in background
• JSON Lines protocol for communication
• DataFrame transfer using Apache Arrow
• Remote object lifecycle management