Copy-paste drift
The same function is duplicated across repos and notebooks. Nobody knows which copy is current, and fixes never propagate.
Versioned Python nodes
Local or remote runs
Run history and artifacts
Stop rewriting the same Python in every project.
splime packages a trusted Python function once - versioned and portable - so you can reuse it across projects and run it locally or on another machine, without copying code or redeploying. Publish a function, call it by name, and get the result, logs, and artifacts back.
Publish once
Call from anywhere
Inspect result and artifacts
Library
versioned
clean_features
function / v7 / reusable node
live
risk_report
pipeline / v5 / functions + links
ready
Call
client.call("clean_features")
Input
{"customer_id": 42}
Runs
succeeded
queued
assigned
running
artifacts
laptop
local
gpu-box
online
result = client.call(
"risk_report",
kwargs={"seed": 42},
target_machine="gpu-box",
)
Result
10.5 sec
r2
0.7629
rmse
4.619
report.html
stderr.txt
stdout.txt
The problem
The same useful function lives in five repos - and none of them agree.
Your best Python already exists: the feature cleaner, the scoring function, the report builder, the one-off script that quietly became load-bearing. But it is trapped in a notebook or an old project, so the next team copy-pastes it, edits it, and the versions drift apart. Running it somewhere else means recreating the environment by hand.
Trapped where it was written
Useful code is stuck on one laptop or in one project. Reusing it elsewhere means rebuilding the environment and the imports from memory.
Wrong machine for the job
The function you need to run lives on your laptop, but the data or the GPU lives on a machine you would rather not expose to the internet.
No history, no proof
When it does run, the result, logs, and output files scatter. There is no shared record of what ran, with which inputs, and what it produced.
How it works
Package a function once. Reuse it everywhere - locally or on a private machine.
splime turns a Python function or pipeline into a versioned, portable node you publish to a private library. Then any project can call it by name, run it where the data or the hardware lives, and read back the result and artifacts. The central server only coordinates: your private workers execute the code.
Publish trusted Functions and Pipelines
Serialize a function or pipeline into a versioned SPL object - source, inputs, outputs, and dependencies - so it is reproducible and immutable, not a fragile pickle.
Call it from any project
Import it back by name in a notebook, script, or service. The same node is reusable across projects without re-pasting or rewriting code.
Run where it makes sense
Run locally during development, or hand a concrete version to a private worker that has the data, the GPU, or the credentials. The daemon builds an isolated environment first.
Get a clean result back
Inspect run timelines, results, and artifacts from one console instead of digging through notebooks - with a shared record of every run.
Local or remote
Send the run to the right machine. Continue where you started.
A notebook, service, or console user hands one concrete node version to an allowed private worker, waits for the result, then keeps the surrounding work moving on the origin machine. You never have to open that worker to the public internet.
Origin keeps context
Inputs, follow-up code, and the final workflow stay with the caller.
Worker owns execution
The target daemon builds the environment, runs the node, and captures artifacts.
Server coordinates only
Jobs, leases, run events, results, and artifact metadata move through splime.
First run
From a function to a reusable node in three steps.
Start with one trusted Python function. splime makes the path obvious: register an environment, publish the node, then call it - locally first, and on a private worker when you need a different machine.
client.register_env()
client.publish(clean_features,
name="clean_features")result = client.call(
"clean_features",
kwargs={"customer_id": 42})client.call("clean_features",
target_machine="gpu-box")
# inspect Runs for logs/artifacts
What you get back
The return value, stdout, stderr, and any output files - plus a versioned record in the library and a row in Runs you can re-open later.
Developer experience
It starts from the Python your team already trusts.
The user API stays small: register an environment, publish the function you already wrote, then call it by name. Add a target machine only when you want the run to happen somewhere else.
from spl.client import SPLClient
client = SPLClient()
# Publish a function you already trust as a versioned node
client.register_env()
client.publish(clean_features, name="clean_features")
# Reuse it from any project - run locally...
result = client.call("clean_features", kwargs={"customer_id": 42})
# ...or send the run to a private machine that has the data
result = client.call(
"clean_features",
kwargs={"customer_id": 42},
target_machine="secure-worker-01",
)
print(result.value)Who feels it first
Built for teams whose useful Python already exists.
Data and ML teams
Turn preprocessing, scoring, validation, reports, and model utilities into reusable Functions and Pipelines with reproducible environments - shared, not copy-pasted.
Platform teams
Give developers self-service access to trusted libraries and launch-only machines without rebuilding orchestration for every project.
Automation teams
Reuse document processing, analytics, and operational scripts across clients, repos, and workers - with narrow external execution tokens when a service needs access.
Security model
Not random code execution. A private registry for trusted code.
splime runs code you publish on purpose, on machines you control. It is built around explicit ownership, scoped access, private worker boundaries, and an auditable run history. The server coordinates; your private workers execute the code.
Private daemon agents
Workers connect outbound to the control plane and keep code execution on your machines.
Scoped tokens and grants
Team grants, delegated machine access, and external execution tokens map to backend permissions.
Narrow run write boundaries
Only the requester can cancel or retry a run; only the requester or target machine can upload artifacts.
Audited operations
Token, grant, settings, run, and artifact-upload events are recorded.
Private beta
Bring one painful internal Function or Pipeline. Make it portable.
The fastest way to understand splime is to publish a real callable from an old project, run it on a different machine, and get a clean result back without copying code. splime is an early private beta - see exactly what works today on the status page.