Eugo Documentation
Eugo gives you instant access to supercomputingSupercomputing refers to the use of extremely powerful computers, known as supercomputers, to perform complex and large-scale computations at very high speeds. resources through a browser-based development environment.
Write Python code in your browser, and run the parts you choose on an HPCHigh Performance Computing is the use of supercomputers and parallel processing techniques to solve complex computational problems. cluster that Eugo starts and manages for you. No infrastructure to manage. No environment setup. No deployment pipelines.
What You Get
Zero setup — Create an account, deploy a workspace, and start coding. Your environment includes hundreds of pre-installed libraries.
Automatic scaling — Each worker pool in your cluster grows under load and shrinks back when the work drains, between the minimum and maximum number of workers you set for it.
Optimized execution — The libraries you import are built for the hardware your code runs on, including its SIMDSingle Instruction, Multiple Data is a type of parallel processing that allows a single instruction to perform the same operation on multiple data points simultaneously. instructions and, on a machine that has one, its GPU. Work runs on the GPU when your code puts it there.
Standard Python — Use familiar libraries like NumPy, pandas, scikit-learn, and PyTorch. Bring your own dependencies when needed.
Common Use Cases
You can use Eugo for any compute-intensive workload:
- Machine learning — Train models on large datasets, run inference at scale
- Data processing — Transform and analyze terabytes of data
- Scientific computing — Protein folding, genomic analysis, particle physics simulations
- Geospatial analysis — Process raster and vector data at scale
- Financial modeling — Run complex simulations and risk analyses
- Image processing — Batch processing and computer vision tasks
If your code takes too long to run or you're hitting memory limits, Eugo can help.
Quick Example
import numpy as np
from numpy.typing import NDArray
from scipy.linalg import norm
from aws_lambda_powertools.logging import Logger
logger = Logger(service="eugo_example.py")
def process_matrices(
*,
matrix1: NDArray[np.float64],
matrix2: NDArray[np.float64],
scalar: int | float
) -> NDArray[np.complex128]:
"""
Processes two matrices by performing a series of operations:
addition, scaling, Fast Fourier Transform (FFT), matrix norm calculation,
and returning the conjugate transpose.
Parameters
----------
matrix1 : numpy.ndarray
First matrix of shape (M, N) with float64 elements.
matrix2 : numpy.ndarray
Second matrix of shape (M, N) with float64 elements.
scalar : int or float
Scalar value to multiply the summed result by.
Returns
-------
numpy.ndarray
Conjugate transpose of the FFT result (complex128 array).
Raises
------
ValueError
If the input matrices do not have the same shape.
Notes
-----
This function combines several steps:
1. Adds `matrix1` and `matrix2`.
2. Scales the result by `scalar`.
3. Computes a 2D FFT on the scaled result.
4. Computes the Frobenius norm of the FFT result.
5. Returns the conjugate transpose of the FFT result.
Example
-------
>>> matrix1 = np.array([[1.0, 2.0], [3.0, 4.0]])
>>> matrix2 = np.array([[5.0, 6.0], [7.0, 8.0]])
>>> scalar = 2
>>> result = process_matrices(matrix1=matrix1, matrix2=matrix2, scalar=scalar)
>>> logger.info(f"Result: {result}")
"""
# Ensure both matrices have the same shape
if matrix1.shape != matrix2.shape:
raise ValueError("Matrices must have the same shape.")
# Add the matrices
result = matrix1 + matrix2
# Scale the result by the scalar
scaled_result = result * scalar
# Perform a 2D Fast Fourier Transform
fft_result = np.fft.fft2(scaled_result)
# Compute the Frobenius norm of the FFT result
frobenius_norm = norm(fft_result, ord='fro')
logger.info(f"Frobenius norm of FFT result: {frobenius_norm}")
# Return the conjugate transpose of the FFT result
return np.conjugate(fft_result.T)
Example usage:
# Example usage:
matrix1 = np.array([[1.0, 2.0], [3.0, 4.0]])
matrix2 = np.array([[5.0, 6.0], [7.0, 8.0]])
scalar = 2
conjugate_transpose_result = process_matrices(matrix1=matrix1, matrix2=matrix2, scalar=scalar)
logger.info(f"Conjugate Transpose of FFT Result: {conjugate_transpose_result}")
This code runs as written in your notebook, using libraries built for the hardware it runs on. To run parts of your code on a cluster, mark a function with @eugo.hpc.distribute, call it with .remote(...), and read the results with eugo.hpc.get(...), as shown in Spreading Work Across Your Cluster.
Tip: See the EugoIDE documentation for more examples and details.
How It Works
- Write Python — Use the EugoIDE notebook interface to write standard Python code
- Run — Execute cells as you normally would in Jupyter
- Scale out when you choose — Start a cluster, mark the functions that should run on it with
@eugo.hpc.distribute, call them with.remote(...), and collect the results witheugo.hpc.get(...) - Get results — Output appears in your notebook, just like local execution
Eugo provisions and manages the infrastructure, and your libraries come built for your hardware. You write the code and choose which parts run on the cluster.
Platform Features
Managed infrastructure — Eugo provisions, scales, and maintains all compute resources. No DevOps required.
Dynamic scaling — Resources allocate based on your workload. You never overprovision.
Cost efficient — Pay only for what you use. Serverless clusters exist only when needed.
Multiple frameworks — Use Ray and PyTorch together in the same workspace.
Energy efficient — Built entirely on Arm architecture (aarch64) for better power efficiency than traditional supercomputers.
Get Started
Ready to start? Follow the Quickstart guide to create your first workspace and run code in minutes.
Sign up for an account to begin.