Modal Alternatives

Six GPU clouds to replace <em>Modal</em>, compared on what an H100 really costs, how they scale to zero and how much code you rewrite.

Baseten is the best Modal alternative for teams that serve a model in production in 2026: multi-cloud capacity with failover across more than 20 cloud providers, dedicated inference and ready-made model APIs, at a higher hourly rate than Modal. Beam is the closest match to Modal's own workflow, with an open-source runtime and GPU machines with an H100 from $1.83 an hour against $3.95 on Modal, and RunPod rents always-on GPU pods by the second, from $1.99 per H100 an hour on its Community Cloud. We compared six alternatives on developer experience, cold starts and scaling, GPU price per hour, pricing clarity and production readiness, with every price read on the vendor's own pricing page.

Romain CochardCEO of Hack'celeration
Updated 20266alternatives compared7comparison guides read2026prices checked

The ranking is editorial: a sponsored placement is always flagged on its card, and no affiliate link changes a score.

The honest take

Why teams look past Modal

Modal is a serverless cloud for Python: you decorate a function, Modal builds the container, runs it on CPUs or GPUs, scales it from zero to hundreds of copies and bills by the second while it runs. Developers praise how little infrastructure they have to touch. The reasons teams leave are about what happens once a workload grows, stops being spiky, or has to live inside a company's own cloud.

Sustained GPUs cost more than renting

An H100 lists at $0.001097 a second on Modal, about $3.95 an hour. Kept busy for a 730-hour month, that is about $2,884. The same month on a RunPod Secure Cloud H100 PCIe pod at $2.89 an hour is about $2,110, and a Beam H100 machine starts at $1.83 an hour. Serverless pricing pays off when the GPU sits idle most of the time, not when it never does.

Multipliers raise the list price

Choosing a region multiplies base prices by 1.15 to 1.75, and non-preemptible execution by 3. Sandboxes are always billed at the non-preemptible rate of 3x list price. An H100 pinned to a region and protected from preemption can cost far more than the $3.95 an hour on the pricing table.

Plan limits arrive early

The free Starter plan allows up to 3 seats, 100 containers, 10 concurrent GPUs and 1 day of log retention. A fourth teammate, an eleventh GPU or a week of logs means Team at $250 a month plus compute, which lifts the cap to 50 GPUs and 30 days of logs. Higher GPU concurrency is on Enterprise only.

The SDK ties code to Modal

Modal's images, volumes, secrets and web endpoints are declared in Python with Modal's own SDK. That is what makes it fast to start, and also what makes it slow to leave: moving to a container platform means writing a Dockerfile and a request handler for each function. Teams that want one container format across clouds pick a platform that runs any Docker image.

No self-hosting or bring your own cloud

Modal runs on Modal's infrastructure. You can buy it through the AWS and GCP marketplaces to draw down committed cloud spend, but you cannot point Modal at your own instances, so data that must stay in your own cloud account cannot stay there. Beam's Bring Your Own Cloud and its open-source runtime, and the hyperscalers' own ML platforms, cover that case.

Cold starts still exist

Scaling to zero means the first request after a quiet period waits for a container to start and a model to load into GPU memory. Memory snapshots shorten that wait, but user-facing apps often end up keeping containers warm, and a warm container is billed like any other. Practitioners describe Modal as cheap for spiky work and expensive for always-on endpoints.
At a glance

6 Modal alternatives compared

Scores are our editorial score out of 5, the plain average of five criteria: developer experience, cold starts and scaling, GPU price per hour, pricing clarity and production readiness. The distinctive column compares each platform's standard H100 rate (dedicated inference on Baseten, a GPU machine on Beam, an on-demand cluster on Together AI, a Secure Cloud pod on RunPod) with Modal's $3.95 an hour ($0.001097 a second). Read the format too: a RunPod pod or a Beam machine stays on until you stop it, while Modal and Cerebrium bill only while code runs.

Best forH100 per hour vs ModalFree planTeam sizeVisit
1BasetenBest Modal alternative for production inference at scale$6.50 vs $3.954.2/5Pay as you go: H100 $6.50 an hour, A100 $4.00 an hour, L4 about $0.85 an hour on dedicated inference, listed per minute; model APIs per token—Scale-ups and enterprisesVisit →
2BeamClosest Modal alternative, with an open-source runtime$1.83 vs $3.954.1/5Developer $20 a month with $20 of credits; Team $89 a month plus usage; serverless RTX 4090 $0.69 an hour, GPU machines with an H100 from $1.83 an hour—Solo devs to 50-GPU teamsVisit →
3Together AIBest for open-source LLMs and fine-tuning$3.99 vs $3.954.0/5Serverless models per token; dedicated endpoints from $5.49 per H100 an hour; GPU clusters from $3.99 per H100 an hour on demand, $1.99 preemptible—LLM teams of any sizeVisit →
4ReplicateEasiest way to run public models through an API$5.49 vs $3.953.9/5Per second of hardware: T4 $0.81 an hour, L40S $3.51, A100 80 GB $5.04, H100 $5.49; some public models per image or per token—Product teams, prototypesVisit →
5CerebriumBest for real-time voice and low-latency apps$3.40 vs $3.953.8/5Free plan to start; Standard $100 a month plus compute; H100 $3.40 an hour, A100 80 GB $2.10, L4 $0.80, billed per second✓Startups, real-time appsVisit →
6RunPodBest for raw GPU pods and serverless on one account$2.89 vs $3.953.7/5Pods: H100 PCIe $2.89 an hour on Secure Cloud or from $1.99 on Community Cloud, A100 PCIe $2.09; serverless H100 $5.89 an hour; billed per second—ML engineers, trainingVisit →

Prices read on each vendor's pricing page in 2026, before taxes, regional multipliers and storage. The ranking is editorial: a sponsored placement is always flagged on its card, and no affiliate link changes a score.

Is your tool missing from this page? Email us: hello@hackceleration.com

1
Best Modal alternative for production inference at scale

Baseten

4.2/5

Baseten is an inference platform: you package a model, Baseten runs it on dedicated GPUs that scale up and down with traffic, and you call it through an API. It also sells ready-made model APIs, priced per million tokens, for popular open models. Where Modal is a general serverless cloud for any Python function, Baseten is built around one job, serving models in production, and it shows in the details: multi-cloud capacity across more than 20 cloud providers with failover, per-deployment autoscaling settings, and dashboards for latency and throughput. The trade-off is price. An H100 lists at $6.50 an hour on Baseten against $3.95 an hour on Modal, so a team that keeps one H100 busy all month pays about $4,745 instead of about $2,884. You pay that gap for capacity and support you would otherwise build yourself. For short batch jobs or a weekend prototype, Modal's $3.95 H100 billed by the second stays the better fit.

Standout features
  • Multi-cloud capacity across 20+ cloud providers
  • Ready-made model APIs per token
  • Dedicated inference and training on one bill
+Pros
  • ✓Failover across clouds keeps an endpoint up during a provider outage
  • ✓Model APIs let you start without deploying anything
  • ✓No monthly platform fee on pay as you go
−Cons
  • ✗H100 at $6.50 an hour, about 65% above Modal's list rate
  • ✗GPU rates listed per minute, where Modal bills per second
  • ✗Volume discounts need a sales conversation
Baseten vs Modal
CriterionBasetenModal
H100 per hour$6.50$3.95
Platform feeNone on pay as you go$0 Starter, $250 Team
Main focusModel inferenceAny Python workload
Verdict

Take Baseten when the model is your product and an outage costs more than the GPU bill. Stay on Modal, or pick Beam, if your workloads are short, bursty jobs where the hourly rate matters most.

Visit Baseten →
2
Closest Modal alternative, with an open-source runtime

Beam

4.1/5

Beam is the alternative that feels most like Modal. You write Python, add a decorator, and Beam runs the function in a container on a GPU, scales it to zero when idle and bills by the millisecond while the code runs. It adds sandboxes for untrusted code that start in about half a second, persistent Linux VMs for agents, and GPU machines rented by the hour. Its runtime, beta9, is published on GitHub under the AGPL-3.0 license, so you can self-host it, which Modal does not offer. Bring Your Own Cloud runs Beam's scheduler on instances in your AWS or GCP account for a flat management fee, so committed cloud credits keep their value. Prices are lower than Modal's on most lines: an H100 machine starts at $1.83 an hour with its CPU, RAM and NVMe included. The catch is scale: the Team plan caps you at 50 concurrent GPUs, the same ceiling as Modal Team, and the company is smaller, so check support terms before you move a production endpoint.

Standout features
  • Open-source runtime (beta9, AGPL-3.0)
  • Bring Your Own Cloud on AWS or GCP
  • No egress or bandwidth fees
+Pros
  • ✓Decorator-based Python SDK, so Modal code ports with few changes
  • ✓H100 machines from $1.83 an hour, CPU and RAM included
  • ✓Team plan at $89 a month against $250 on Modal
−Cons
  • ✗Team plan includes 3 seats, then $25 per extra seat
  • ✗Smaller company and community than Modal
  • ✗AGPL-3.0 license has obligations if you modify and expose the runtime
Beam vs Modal
CriterionBeamModal
Team plan$89 a month$250 a month
Self-hostingYes, beta9 is open sourceNo
Billing unitPer millisecondPer second
Verdict

Take Beam if you want to keep Modal's way of working and pay less for GPUs, or need to run on your own AWS account. Pick Baseten instead if you need enterprise-grade uptime guarantees for a customer-facing model.

Visit Beam →
3
Best for open-source LLMs and fine-tuning

Together AI

4.0/5

Together AI starts from the model rather than the container. Its serverless API serves a large catalog of open-weight language, image and audio models, billed per million tokens, behind an OpenAI-compatible endpoint (our ranking of LLM APIs compares it with the other per-token providers). When you need your own copy, a dedicated endpoint reserves GPUs for one model, and fine-tuning jobs are priced per token trained. For training, it rents GPU clusters by the hour, with H100s at $3.99 on demand, $1.99 preemptible, and $3.45 when reserved for 31 to 90 days. That covers a lot of what teams use Modal for when the workload is an LLM: there is no Python function to write, no image to build and no cold start on the shared serverless models. What it does not replace is the general-purpose side of Modal. You cannot run an arbitrary Python job, a scraper or a video pipeline on Together's serverless API, and a dedicated H100 endpoint at $5.49 an hour costs more than an H100 on Modal.

Standout features
  • Catalog of open-weight models behind one API
  • Fine-tuning priced per token
  • GPU clusters with reserved discounts
+Pros
  • ✓No serving code for popular open models
  • ✓Preemptible H100s at $1.99 an hour for training
  • ✓Reserved pricing drops the H100 to $3.45 an hour
−Cons
  • ✗Its serverless API runs catalog models, not your own Python jobs
  • ✗Dedicated H100 endpoint at $5.49 an hour, above Modal's $3.95
  • ✗Custom models outside the catalog need a dedicated endpoint
Together AI vs Modal
CriterionTogether AIModal
H100 per hour$5.49 dedicated, $3.99 cluster$3.95
Serving codeNone for catalog modelsYou write it
BillingPer token or per GPU hourPer second
Verdict

Take Together AI if your Modal bill is mostly an open LLM you serve or fine-tune. Keep Modal, or move to Beam, for anything that is not a model call: batch jobs, scrapers, media pipelines.

Visit Together AI →
4
Easiest way to run public models through an API

Replicate

3.9/5

Replicate is a marketplace and a runtime at once. Thousands of public models, from FLUX image generators to video and speech models, run behind a single API, and you pay either per output (an image, a second of video) or for the seconds of hardware the model uses. To run your own model, you package it with Cog, Replicate's open-source container tool, and push it as a private model or a deployment with minimum and maximum instances. This is the fastest route from idea to working API on this page. The catch is the bill for private work: hardware prices are well above Modal's (an H100 at $5.49 an hour against $3.95), and private models are billed for the time they are online, idle time included, unless you use fast-booting fine-tunes. Deployments let you cap the maximum instances, which is the setting to change first if you migrate a spiky Modal workload.

Standout features
  • Thousands of public models behind one API
  • Cog, an open-source packaging tool
  • Per-output pricing on many public models
+Pros
  • ✓A working model API in minutes, no infrastructure to design
  • ✓Pay per image or per second of output on public models
  • ✓Deployments can keep instances warm or scale to zero
−Cons
  • ✗H100 at $5.49 an hour, about 39% above Modal
  • ✗Private models bill idle time while they are online
  • ✗Less control over the container than Modal or Beam
Replicate vs Modal
CriterionReplicateModal
H100 per hour$5.49$3.95
Public model catalogThousands of modelsTemplates and examples
Idle time on private modelsBilled while onlineNot billed
Verdict

Take Replicate when the model already exists and you want an API today. For custom models with steady traffic, Baseten or Beam will cost less per hour.

Visit Replicate →
5
Best for real-time voice and low-latency apps

Cerebrium

3.8/5

Cerebrium is a serverless GPU platform close to Modal in shape: you deploy a Python app in a container, it scales to zero, and you pay per second of GPU, CPU and memory. It aims at real-time workloads such as voice agents and transcription, and it lists rates below Modal's on the main GPUs: an H100 at $3.40 an hour against $3.95, an A100 80 GB at $2.10 against $2.50. Memory costs $0.00000222 per GB per second, the same figure Modal charges per GiB. The Standard plan costs $100 a month plus compute, less than Modal Team at $250. For bursty traffic that still needs guaranteed GPUs, Cerebrium sells reserved access without paying for idle capacity, with a minimum monthly spend; its own example guarantees up to 50 H100s for $10,000 a month. The limits: a smaller ecosystem than Modal, fewer published examples, and a focus on inference rather than sandboxes or general batch work.

Standout features
  • H100 at $3.40 an hour, per second
  • Guaranteed capacity without paying for idle GPUs
  • Free plan, then $100 a month
+Pros
  • ✓Cheaper than Modal on H100 and A100 80 GB list prices
  • ✓Standard plan at $100 a month against $250 for Modal Team
  • ✓Billing example shows the cost per request before you deploy
−Cons
  • ✗Guaranteed capacity comes with a minimum monthly spend ($10,000 in its own example)
  • ✗Smaller community and fewer templates than Modal
  • ✗Inference-first: no general sandboxes product
Cerebrium vs Modal
CriterionCerebriumModal
H100 per hour$3.40$3.95
Paid plan$100 a month$250 a month
Memory per second$0.00000222 per GB$0.00000222 per GiB
Verdict

Take Cerebrium for a latency-sensitive inference app that needs Modal's serverless model at a lower rate. Stay on Modal if you also rely on sandboxes, cron jobs or its larger library of examples.

Visit Cerebrium →
6
Best for raw GPU pods and serverless on one account

RunPod

3.7/5

RunPod rents GPUs two ways. Pods are GPU machines you start and stop yourself, billed per second with no commitment, in a Secure Cloud of vetted data centers or a Community Cloud of third-party hosts. Serverless runs your Docker image as workers that scale with a queue of requests. For sustained work, pods are where RunPod beats Modal: an H100 PCIe costs $2.89 an hour on Secure Cloud and from $1.99 on Community Cloud, against $3.95 an hour on Modal, and a GPU that runs all month costs about $2,110 instead of about $2,884. Serverless is another story: its H100 is listed at $5.89 an hour, above Modal. You also do more work: RunPod runs standard containers, so you write the Dockerfile and the handler that Modal's decorators generate for you, and stopped volumes keep billing for storage. Our RunPod review scores it 3.7 out of 5, and RunPod pricing details every GPU.

Standout features
  • Pods and serverless on the same account
  • Community Cloud from $1.99 per H100 an hour
  • Standard Docker images, no proprietary SDK
+Pros
  • ✓On-demand pods in 31 global regions
  • ✓Per-second billing with no commitment
  • ✓No SDK lock-in: any container runs
−Cons
  • ✗Serverless H100 at $5.89 an hour, above Modal
  • ✗More setup: Dockerfile, handler, networking
  • ✗Idle volume storage costs $0.20 per GB a month
RunPod vs Modal
CriterionRunPodModal
H100 per hour$2.89 pod, $5.89 serverless$3.95
PackagingAny Docker imageModal Python SDK
Idle volume disk$0.20 per GB a monthVolumes $0.09 per GiB a month, first 1 TiB free
Verdict

Take RunPod for training runs and always-on inference where the hourly rate is the whole decision. For spiky traffic that scales to zero, look at Beam or Cerebrium, which bill only while code runs. See our RunPod alternatives if you are already there.

Visit RunPod →Read our RunPod review
Feature by feature

Modal vs its alternatives, the details that change the bill

The same five questions for each platform: how it bills, what an A100 80 GB costs, whether it runs on your own cloud, how you package code and what the paid plan costs. Prices are list prices for one GPU, before multipliers.

AlternativesModalEdge
Billing unitPer millisecond (Beam), per second (Cerebrium, RunPod, Replicate), per minute rates (Baseten), per token (Together AI)Per second—
A100 80 GB per hourCerebrium $2.10, RunPod A100 SXM pod $2.19, Baseten $4.00, Replicate $5.04$2.50—
Own cloud or self-hostingBeam: Bring Your Own Cloud on AWS or GCP, open-source runtimeNot offered—
PackagingDocker image (RunPod), Cog (Replicate), Python SDK (Beam, Cerebrium), none for catalog models (Together AI)Modal Python SDK—
Paid planBeam Team $89, Cerebrium Standard $100, others pay as you goTeam $250 a month plus compute—
Free monthly creditsBeam Developer: $20 of credits for $20 a monthStarter: $30 a month; Team: $100 a month—

Read on each vendor's pricing page in 2026.

Moving off Modal

How to migrate from Modal in five steps

Model code and weights are portable; what you rewrite is the glue Modal generates from its decorators. Plan a week for one service, and run both platforms in parallel before you switch traffic.

01

List what Modal does for you

1 day

For each Modal app, write down its image, GPU type, volumes, secrets, schedules, web endpoints and concurrency settings. These are the pieces you will recreate. Note the monthly GPU hours from your billing page: it decides between a serverless and an always-on platform (see the break-even in the buyer's guide).

Output
One line per function
02

Turn the image into a container

1 to 2 days

Rewrite the Modal image as a Dockerfile (RunPod, Baseten), a Cog file (Replicate) or keep Python decorators (Beam, Cerebrium). Bake model weights into the image or a volume so the first request does not download them.

Watch
Image size and load time
03

Recreate the endpoint and secrets

1 day

Wrap your function in the target platform's handler, move API keys into its secrets store, and match the request and response format so your app does not change.

Test
Same payload, same output
04

Test cold starts and the tail

1 day

Send real traffic patterns, including the first request after an idle hour. Compare the slowest requests, not the average: that is what users feel. Set minimum and maximum instances to cap spend.

Measure
Slowest 1% of requests
05

Switch traffic, then shut Modal down

1 day

Move a share of traffic first, watch errors and cost for a few days, then move the rest. Stop Modal deployments and delete volumes you no longer need so they stop counting against your plan.

Keep
A rollback path for a week
Buyer's guide

How to choose a Modal alternative

A serverless GPU platform runs your code in containers on rented GPUs and starts or stops those containers as requests arrive, so you pay for compute only while it works. It sits between two other options. Below it, a GPU cloud rents you a dedicated GPU server by the hour: a lower hourly rate, but you pay while it idles and you manage the software. Above it, an inference provider serves ready-made models per token or per image: no code to deploy, but only the models on the menu. Modal, Beam and Cerebrium are serverless platforms; RunPod and Lambda rent GPUs; Together AI and Replicate lean toward model APIs; Baseten covers dedicated inference. Before you compare names, write down three numbers from your Modal bill: GPU hours per month, the peak number of GPUs running at once, and the share of time they sit idle. Then demand four things from each vendor: the billing unit, the multipliers or minimums on top of list price, the concurrency cap on each plan, and whether you can run on your own cloud. For a wider view of raw GPU rental, see our GPU cloud ranking, and for model hosting with a large community, our Hugging Face review: Hugging Face Inference Endpoints rent dedicated GPUs by the hour, from $0.50 for a T4 to $2.50 for an A100, and our Hugging Face alternatives list the other hosts.

Learn the units on the bill

A GPU-second is one second of one GPU, the unit Modal, Cerebrium and Replicate bill. A GPU-hour is 3,600 of them: Modal's H100 at $0.001097 a second is $3.95 an hour. CPU is billed per core and memory per GiB per second, on top of the GPU. A token is a piece of text of about three quarters of a word, the unit of model APIs such as Together AI. Concurrency is the number of GPUs that can run at the same time, capped by plan.

Trap 1: the break-even with an always-on GPU

Serverless wins only while the GPU is idle much of the time. An H100 on Modal costs $3.95 an hour; a RunPod Secure Cloud H100 PCIe pod costs $2.89 an hour, running or not. The pod costs less as soon as the serverless GPU is busy for more than about 73% of the hours (2.89 / 3.95). With a Beam H100 machine from $1.83, the break-even falls to about 46% of the time.

Trap 2: multipliers on the list price

Modal multiplies base prices by 1.15 to 1.75 when you choose a region and by 3 for non-preemptible execution. An H100 pinned to a region at 1.75x costs about $6.91 an hour, and non-preemptible at 3x about $11.85. Ask each vendor which of your requirements change the rate before you compare tables.

Trap 3: idle time that is still billed

Replicate bills private models for the time they are online, idle included, unless they are fast-booting fine-tunes. RunPod bills idle volume disks at $0.20 per GB a month, twice the running rate of $0.10. A container kept warm to avoid cold starts is billed as running time. Price the idle hours, not just the busy ones.

Trap 4: plan caps that force an upgrade

Modal Starter stops at 3 seats and 10 concurrent GPUs; Team at $250 a month lifts that to 50. Beam Team at $89 a month also stops at 50 concurrent GPUs and includes 3 seats, then $25 per seat. Cerebrium guarantees reserved capacity against a minimum monthly spend. Check the cap you will hit in six months, not today.

Test on your own model

Published cold-start numbers come from vendors' own benchmarks. Deploy your real model on two platforms, send the first request after an idle hour, and compare the slowest requests. Most platforms give enough free or monthly credits for that test: $30 a month on Modal Starter, $20 on Beam Developer.
  • What is the billing unit: millisecond, second, minute, hour or token?
  • Which multipliers or minimums apply to my region and uptime needs?
  • How many GPUs can run at once on the plan I would buy?
  • Can it run in my own AWS or GCP account?
  • Do I keep my container, or rewrite it for a proprietary SDK?
  • Is idle time billed for warm instances and stored volumes?
FAQ · 8 questions

Modal alternatives, your questions

  • What is Modal used for?
    Modal runs Python code in the cloud on CPUs or GPUs without servers to manage: model inference, fine-tuning, batch jobs, scheduled tasks, web endpoints and sandboxes for untrusted code. You describe the container and hardware in Python, and Modal scales the function from zero to many copies, billing by the second.
  • Can I run long training jobs on Modal or an alternative?
    On Modal, only in pieces: a function times out after 5 minutes by default, and you can raise that limit to 24 hours at most, so a longer run needs checkpoints and restarts. A RunPod pod runs until you stop it, billed per second, and Together AI reserves H100 clusters for 3 to 90 days, at $3.45 an hour per GPU on a 31 to 90 day reservation.
  • How does Modal bill CPU and memory?
    Separately from the GPU, by the second. CPU costs $0.0000131 per physical core per second, a core being two vCPUs, with a minimum of 0.125 cores per container; memory costs $0.00000222 per GiB per second, with a minimum of 128 MiB. A GPU container therefore always costs a little more than the GPU line alone.
  • Why do Modal Sandboxes cost more than Functions?
    Sandboxes are billed at non-preemptible rates of 3x list price, because they cannot be interrupted and moved. A sandbox doing the same work as a function costs about three times as much, so long-running agent sandboxes are where Beam's sandboxes, from $0.06 an hour, are worth comparing.
  • Does Modal charge for network egress?
    Each plan includes some free network egress; the Starter plan lists 1 TiB a month. Beyond that, data leaving Modal is billed. Beam states it charges no egress or bandwidth fees on any plan, which matters for media or large file outputs.
  • Can I use my AWS or GCP committed spend on Modal?
    Yes, through the AWS and GCP marketplaces: buying Modal there draws down the committed spend you already have with that cloud. Your workloads still run on Modal's infrastructure, not on your own instances; to run inside your own AWS or GCP account, Beam's Bring Your Own Cloud charges a management fee of $0.019 per vCPU an hour and $0.009 per GB of RAM, and the instances bill to your cloud account.
  • Can I run Modal code on another platform without rewriting it?
    Not as is: Modal's decorators, images and volumes only run on Modal. Your model code and weights move unchanged, but the container definition and endpoint need rewriting, as a Dockerfile, a Cog file or another SDK. Beam's Python SDK is the closest in style, so its port is usually the shortest.
  • Is there an open-source alternative to Modal?
    Yes, Beam's runtime, beta9, is published on GitHub under the AGPL-3.0 license, and describes itself as serverless GPU inference, sandboxes and background jobs. You can self-host it on your own GPUs; the AGPL requires sharing changes if you modify it and offer it to users over a network.
Hack'celeration Lab

Get the next breakdown in your inbox

No spam. Unsubscribe anytime.