mrkeyoor.com_
Thu 10 Sept 16:48 UTC
Self-Hostedevaluationupdated 10 Sept 2026

gpustack review

GPUStack is a self-hosted control plane for sharing GPU clusters, deploying AI models, and issuing SSH-accessible GPU instances. It schedules work across machines, configures inference engines such as vLLM and SGLang, and exposes model APIs with authentication, routing, metrics, and usage records.

trackingstars / 7d
Verdict

Our GPUStack run installed 157 packages and used 525 MB, then 3,738 of 3,757 tests passed while 19 Kubernetes manifest tests failed, so this is a serious platform with a source-checkout caveat. Use it when you already have several Linux GPU workers and need one place for placement, model routes, access control, and usage. For a single model server, its control plane is extra work; for a shared fleet, the documented hardware breadth and scheduler make a trial worthwhile.

We ran it

Lab card: what happened when we ran gpustackScreenshot of gpustack (gpustack.ai)
Install✓ · 52s157 packages · 525 MB
Build✓ · 7s
Tests✗ · 237s3738 passed · 19 failed · 71 skipped of 3757 (pytest)
Known vulns0(pip-audit)
Repo1362 files~228,133 lines of source · 88.2 MB · 6 CI workflows · tests dir

Answers from our run

Does gpustack build from source?

Dependencies installed in 52 seconds (157 packages), and the build succeeded in 7 seconds. We cloned commit 76dc841 into a clean Debian container with 3 CPUs and no project-specific setup.

Do gpustack's tests pass?

Not all of them: 3738 of 3757 passed and 19 failed when we ran the project's own test command (pytest). Some failures need services or credentials a bare container does not have.

Does gpustack have known vulnerabilities in its dependencies?

pip-audit found none in the dependency tree at the time of our run.

Who should not use gpustack?

Teams with one model on one server: a direct vLLM or SGLang deployment avoids GPUStack's server, scheduler, gateway, database, and worker layer.

What are the alternatives to gpustack?

vLLM, KubeAI, Ray. Our GPUStack run installed 157 packages and used 525 MB, then 3,738 of 3,757 tests passed while 19 Kubernetes manifest tests failed, so this is a serious platform with a source-checkout caveat.

Setup2/5Docker starts the server; real workers need privileged GPU plumbing
Docs5/5Hardware, ports, scheduling, access, and recovery are documented
Community4/55,655 stars with active issues, pull requests, and recent pushes
Maturity3/5Version 2.2.3 is substantial, but source tests and auth need review

Who it’s for

Platform teams operating several GPU workers, models, or inference engines.
Organizations serving language, image, audio, or embedding models behind OpenAI-compatible APIs.
Kubernetes and Docker operators who need scheduling, access control, monitoring, and model routing in one system.
Infrastructure providers offering on-demand GPU instances to internal teams or customers.

Who it’s NOT for

Teams with one model on one server: a direct vLLM or SGLang deployment avoids GPUStack's server, scheduler, gateway, database, and worker layer.
Windows or macOS GPU workers: the README says workers support Linux only, with WSL2 suggested for Windows and no macOS worker support.
Environments that prohibit privileged containers, host networking, or mounting the Docker socket: the documented Docker worker command uses all three.
Developers who require direct PyPI installation: the requirements page says that route is unsupported and recommends published Docker images.
Operators who need a clean source-suite result before evaluation: our run had 19 failures in Kubernetes bootstrap-manifest tests.
Teams that revoke keys through direct database changes: issue 6173 reports stale authentication in the fallback path after soft or hard deletion outside the supported API.

Setup reality

Our Python 3.12 sandbox installed 157 packages in 52 seconds and used 525 MB. The build passed in 7 seconds. Tests failed after 237 seconds: 3,738 passed and 19 failed out of 3,757, with 71 skipped. Pip-audit found 0 known vulnerabilities.

The easiest server path pulls a published Docker image, persists /var/lib/gpustack, and exposes port 80. A usable worker needs Linux, vendor drivers, a compatible container runtime, server connectivity, and a registration token. Kubernetes, distributed inference, external databases, cloud provisioning, and SSO add their own credentials and network rules.

The 88.2 MB checkout contained 1,362 files and about 228,133 source lines, with 6 CI workflows, tests, and no Dockerfile. The failed test tail showed missing paths below gpustack/ui/static/charts/ in Kubernetes manifest cases; it did not explain why those files were absent.

One control plane manages clusters, models, and GPU instances

GPUStack separates the server from the machines doing inference. The server exposes the API and UI, stores state, schedules model instances, and reconciles desired replicas. Workers detect accelerators, start inference containers, and report metrics. Higress routes client requests to those instances. The result is one place to manage models and issue SSH-accessible GPU instances instead of treating every GPU host as a hand-built snowflake.

The README lists 9 accelerator families, including NVIDIA, AMD, Ascend, Hygon, MetaX, MThreads, Iluvatar, Cambricon, and T-Head hardware. Support depth varies. The requirements page marks MThreads, Iluvatar, Cambricon, and T-Head experimental, and available inference backends differ by vendor. NVIDIA gets vLLM, SGLang, VoxBox, and custom backends; some other devices have one built-in option plus custom integration. Check the vendor table before assuming a named accelerator can run the engine you want.

Linux workers need privileged access and a wide port range

The quick start makes the server look simple: run a published container, expose port 80, persist /var/lib/gpustack, and read the generated admin password from that volume. A CPU-only host can run the server. The worker is the real infrastructure job. The documented Docker command uses privileged mode, host networking, the host Docker socket, a vendor runtime, a worker token, and an advertised address. Security teams should review that command before a trial.

Worker nodes support Linux on AMD64 or ARM64. Windows users are directed toward WSL2, and macOS cannot act as a worker. Distributed vLLM also needs worker-to-worker connectivity and reserves TCP 41000 through 41999 for Ray services; inference uses 40000 through 40063. NTP is required so node state stays synchronized. These are ordinary cluster requirements, yet they are far beyond the effort implied by starting the server container alone.

Scheduling filters for fit before it scores placement

The scheduler first removes workers with the wrong cluster, labels, status, backend support, selected GPU, or local model path. It then checks whether RAM and VRAM can hold the model. Candidate strategies proceed from one GPU to several GPUs on one worker, then distributed placement, with CPU or partial offload available only for supported model and backend combinations. This ordering is documented clearly enough to diagnose why a model never receives a placement.

After filtering, GPUStack scores placement and model-file locality. Binpack fills fewer GPUs; spread distributes replicas for fault tolerance. Existing files raise a candidate's score, including draft-model files used for speculative decoding. Scale-down uses health, offloaded layers, and placement to decide which replica goes first. The logic is more useful than a generic least-loaded rule, but estimates from GGUF parsers or backends still need confirmation on the exact 8 GB, 24 GB, or larger devices in your fleet.

What happened when we ran it

Our fresh Python 3.12 sandbox installed commit 76dc841 in 52 seconds. The environment gained 157 packages and occupied 525 MB. Building succeeded in 7 seconds, and pip-audit reported 0 known vulnerabilities. The repository itself had 1,362 files, about 228,133 source lines, and an 88.2 MB checkout. Six CI workflow files and a tests directory were present, while no Dockerfile was found.

Tests returned exit code 1 after 237 seconds. Pytest reported 3,738 passed and 19 failed out of 3,757, with 71 skipped. The log tail places the listed failures in tests/k8s/test_bootstrap_manifest.py. Scalar-type and ownership cases raised FileNotFoundError for paths below /work/repo/gpustack/ui/static/charts/. The log does not say why those chart files were missing, so the defensible finding is that this commit did not pass its full suite in our stated container.

API key storage deserves a security review

GPUStack creates an admin account at bootstrap and stores its initial password under the data directory. Users can create API keys with platform-management or model-access permissions, optionally limited to selected models. Auto-generated keys contain 128 bits from a cryptographic random source. Custom strings can be weak, and the documentation warns that their unsalted hashes may be published into gateway configuration and diagnostic bundles unless custom-key gateway authentication is disabled.

Open issue 6173 concerns deletion outside the supported API. It reports that the fallback lookup omitted a deleted_at filter: a raw-SQL soft delete continued authenticating, while a hard or cascade deletion could remain cached until the default 600-second TTL expired or the process restarted. The report notes that the product did not have a normal soft-delete trigger for the first case. This is still worth testing anywhere identity lifecycle or database automation can bypass the normal delete route.

Version 2.2.3 is maintained, with active operational reports

Release v2.2.3 shipped on July 31, 2026, with a fix for Claude Code requests routed through vLLM. GitHub recorded another push on September 10. The repository had 5,655 stars and 684 open issues and pull requests when fetched, so that combined number should not be read as 684 confirmed bugs. Same-day activity included issue 6197, which reports intermittent 409 conflicts when a deleted model name is immediately reused.

GPUStack fits a team that has outgrown one inference container and is ready to own a control plane. Apache-2.0 licensing, multiple backends, an explicit scheduler, external database options, and OpenAI-compatible APIs are credible foundations. The costs are equally concrete: privileged worker access, vendor-specific drivers, broad networking, a 525 MB development environment, and 19 failing Kubernetes tests in our run. A proof of concept should include worker loss, key revocation, model replacement, and one distributed deployment alongside a successful chat request.

Alternatives

ProjectWhat it isPick it when
vLLM gh↗A focused high-throughput server for large language model inference.pick this instead when one LLM endpoint matters more than multi-cluster scheduling and GPU instances.
KubeAIA Kubernetes operator for serving language, vision, embedding, and speech models.pick this instead when Kubernetes is already mandatory and you want a narrower inference operator.
Ray gh↗A distributed compute engine with libraries for training, data, and model serving.pick this instead when custom distributed Python workloads matter as much as managed inference.

What people are saying

  1. [github-trending] gpustack/gpustack

Sources

  1. GPUStack README
  2. GPUStack architecture
  3. GPUStack installation requirements
  4. GPUStack scheduler
  5. GPUStack API key management
  6. API key revocation issue 6173
  7. Model recreation issue 6197
  8. GPUStack v2.2.3 release

More self-hosted reviews

halo · server · ground-station · mastodon · changedetection.io · clash-party · the whole board →