Python-first Private node registry Remote execution

Reuse Python functions across projects without rewriting or redeploying them.

splime packages trusted Python code into versioned, portable nodes. Run them locally, in CI, or on your own remote workers — with typed inputs, reproducible environments, logs, and results streamed back to your machine.

Join the private beta View concept docs

Built for teams whose best internal Python code is scattered across repos, notebooks, scripts, and legacy environments.

▻ splime node 
from splime import node, run_remote

@node(
    name="invoice.cleaner",
    python="3.12",
    resources={"cpu": 2, "memory": "4Gi"},
)
def clean_invoice_pdf(file: bytes) -> dict:
    # Your existing production-proven Python code
    return extract_fields(file)

clean_invoice_pdf.publish("company/invoice-cleaner@1.0.0")

result = run_remote(
    "company/invoice-cleaner@1.0.0",
    file=open("invoice.pdf", "rb").read(),
)

print(result.logs)
print(result.output)

The problem

Internal Python code is valuable. It is also surprisingly hard to reuse.

Teams do not need another place to paste code. They need a safe way to package, discover, run, and govern trusted functions that already solve real business problems.

✓ Useful Python code gets trapped in old repos, notebooks, scripts, and one-off environments.
✓ Moving it into a new project usually means copy-paste, broken dependencies, missing secrets, and unclear ownership.
✓ Remote execution often forces teams into heavyweight schedulers, cloud lock-in, or custom internal tooling.
▣

Package trusted functions

Turn Python functions into versioned nodes with schemas, dependency manifests, resource requirements, and metadata.

↻

Reuse across projects

Publish a node once, import it elsewhere, and compose it into new pipelines without copy-pasting implementation code.

☁

Run locally or remotely

Execute nodes on your laptop, in CI, on internal workers, or inside your own infrastructure while streaming results back.

◇

Designed for private teams

Built around trusted code, signed artifacts, audit logs, isolated workers, and private registries — not public random execution.

How it works

From existing function to reusable execution node.

splime focuses on the boring but essential layer between working Python code and production reuse: packaging, contracts, execution, and governance.

{}
Step 1

Annotate

Wrap an existing Python function as a splime node.

⑂
Step 2

Publish

Version it in your private registry with its runtime contract.

⛓
Step 3

Compose

Import the node into another project or pipeline.

▶
Step 4

Execute

Run it locally or remotely and receive logs, outputs, and artifacts.

Use cases

Start where reuse is already painful.

The first version of splime is intentionally Python-first and private-team-first. It is not trying to be a public function marketplace or a universal workflow engine.

✦

Data & ML teams

Move preprocessing, scoring, enrichment, and validation functions from notebooks into reproducible internal pipelines.

✦

Platform teams

Offer self-service execution for internal Python capabilities without asking every team to rebuild infrastructure.

✦

Consultancies

Reuse proven automation, scraping, document processing, and analytics nodes across client projects safely.

✦

Enterprise automation

Run trusted code inside your perimeter while letting developers trigger remote execution from their own projects.

Security model

Not “upload random serialized code and hope”.

splime is designed around trusted internal code, explicit runtime contracts, isolated execution, and private infrastructure. Serialization is an implementation detail — governance is the product.

Request security notes See architecture →
🔒

Enterprise-safe primitives

A practical trust boundary for reusable functions.

  • Signed, versioned node artifacts
  • Typed input and output contracts
  • Dependency and Python runtime manifests
  • Isolated local or remote workers
  • Secrets passed by reference, not bundled into nodes
  • Execution logs, audit trails, and reproducibility metadata

Positioning

Use splime with your stack, not instead of it.

splime is the portability and execution layer for trusted Python functions. It can complement schedulers, orchestrators, notebooks, CI systems, and internal platforms.

{}

Not another scheduler

Keep Airflow, Prefect, Temporal, or cron. splime helps package and execute the functions those systems call.

☁

Not cloud lock-in

Run nodes on your laptop, internal workers, Kubernetes, CI, or private infrastructure before choosing any hosted layer.

◇

Not a public marketplace first

The starting point is private reuse: trusted code, internal ownership, versioned contracts, and team-level governance.

Private beta

Bring one real function. Make it portable.

The best early test for splime is simple: take a useful function from an old Python project, publish it as a node, import it into a new project, run it remotely, and get the result back with logs and reproducibility metadata.

Request access → Follow progress