⚡
Zero-config scale-out
Go from one core to thousands with a single map(). No cluster to spin up, no capacity planning.
Multi-cloud serverless for Python
Lithops turns your laptop into a supercomputer. Fan a single Python function out to thousands of parallel cloud workers in seconds — no servers, no YAML, no infrastructure to manage.
$ pip install lithops
Write plain Python. Lithops serializes your function and data, provisions the workers, invokes them in parallel across your chosen backend, and streams the results straight back to your session.
A regular Python function and an iterable. No decorators, no rewrites.
The executor packages code + data and invokes workers in parallel.
Thousands of serverless functions run at once, right next to your data.
Results and logs stream back as if it all ran locally.
Go from one core to thousands with a single map(). No cluster to spin up, no capacity planning.
The same code runs on AWS, GCP, Azure, IBM, Oracle, Aliyun, Kubernetes and HPC. Provider details stay transparent.
NumPy, pandas, scikit-learn — your existing code, unmodified. No cloud-specific boilerplate.
Automatic discovery and transparent partitioning of CSV, Parquet and JSON straight from S3-style buckets.
Chase latency with Lambda's millisecond starts, or cut cost with Batch on Spot — same program, your call.
Traceback a remote failure just like a local one. Built-in logging, retries and event sourcing.
Pick an example. This is the whole program — Lithops handles the rest.
# A single serverless invocation
import lithops
def hello(name):
return f'Hello {name}!'
fexec = lithops.FunctionExecutor()
fexec.call_async(hello, 'World')
print(fexec.get_result())
# Estimate Pi with 10 parallel workers
import lithops, random
def is_inside(n):
count = 0
for _ in range(n):
x, y = random.random(), random.random()
if x*x + y*y < 1:
count += 1
return count
np, n = 10, 15_000_000
parts = [n // np] * np
fexec = lithops.FunctionExecutor()
fexec.map(is_inside, parts) # fan out
pi = sum(fexec.get_result()) / n * 4 # fan in
print(f'Estimated Pi: {pi}')
# Map then reduce, in the cloud
import lithops
iterdata = [1, 2, 3, 4]
def my_map(x):
return x + 7
def my_reduce(results):
return sum(results)
fexec = lithops.FunctionExecutor()
fexec.map_reduce(my_map, iterdata, my_reduce)
print(fexec.get_result())
# Unified storage across any cloud
from lithops import Storage
st = Storage()
st.put_object(bucket='mybucket',
key='test.txt',
body='Hello World')
data = st.get_object(bucket='mybucket',
key='test.txt')
print(data)
Swap FunctionExecutor()'s backend in ~/.lithops/config — your code never changes.
Mix serverless functions, containers, VMs, Kubernetes and HPC — Lithops keeps provider management out of your code.
If your problem breaks into many small, independent tasks, Lithops solves it at scale — fast.
Run millions of stochastic trials across thousands of cores and aggregate in seconds.
Powering platforms like MetaSpace on Lambda + EC2 directly over S3.
Tile, process and reduce huge raster/vector datasets in parallel.
Sweep parameter grids and preprocess training data at cloud scale.
Partition CSV/Parquet/JSON automatically and transform terabytes in one pass.
From HPC clusters to pre-exascale supercomputers via the Lithops HPC backend.
Two lines of setup. Zero infrastructure. Start on localhost, deploy to any cloud.
$ pip install lithops && lithops hello