PrintStash vs Manyfold vs STL Shelf, compared

All three replace a folder of badly named STL files with something searchable. They disagree about what the library owes you after you have found the file.

• Choose PrintStash when the library should remember which sliced file printed well, and when you want to send that file to a printer without leaving the model page.
• Choose Manyfold when the collection itself is the point: creators, licenses, related models, and publishing or federating what you own.
• Choose STL Shelf when you want a versioned design library with a hosted option and no Compose stack to maintain.

Feature claims below were checked against each project’s own documentation, repository, and pricing page on August 3, 2026. PrintStash claims describe the shipped v0.12.1 release.

Quick comparison

Capability	PrintStash	Manyfold	STL Shelf
G-code revisions	Revisions attached to the source model, with outcome states and one recommended revision	Indexes and previews G-code files; built-in version control is on the roadmap for Q4 2026	Versions per model file; no G-code handling
Slicer metadata	Parses OrcaSlicer, PrusaSlicer, Bambu Studio, and Cura output, including binary .bgcode	Not documented	Not documented
Printer integration	Five providers. Moonraker/Klipper is stable; PrusaLink, OctoPrint, Bambu LAN, and Elegoo Centauri are beta	Sends sliced files through the OctoPrint, Moonraker, and other printer APIs	None documented
File formats	STL, 3MF, OBJ, STEP/STP, G-code, BGCODE	Wide: meshes, print and slicer files, images, video, documents, archives	STL, 3MF, OBJ, PLY
Existing NAS folders	Shared volumes index local or NAS folders in place and can write new files back	Scans library folders on disk	Files live in S3-compatible object storage
Storage backends	Local disk vault, S3-compatible, or indexed shared volumes	Local disk or S3	S3-compatible only (Cloudflare R2, MinIO, AWS S3)
Deployment	Self-hosted Docker Compose. SQLite and local disk by default, Postgres and S3 optional	Self-hosted Docker Compose, Ruby on Rails, Postgres in production	Self-host with Postgres 14+, Bun 1.1+, and a bucket, or use the hosted service
Hosted option	No	No	Yes, at stl-shelf.com
Multiple users	Accounts, collection roles, per-printer grants, API keys, audit log, optional OIDC/SSO	Multiple users with fine-grained permissions and OIDC	Team organizations with role-based access
Sharing outward	Expiring read-only links	Public or private publishing plus ActivityPub federation, likes, and comments	Sharing inside an organization, plus individual and ZIP downloads
Print history and cost	Job history on the revision, cost and material trends, Spoolman with measured Moonraker consumption	Not part of the product	Not part of the product
License and price	AGPL-3.0, free to self-host	AGPL-3.0, free to self-host	Apache 2.0 to self-host. Cloud runs from a free 0.5 GB tier to $35.99 per month
Extending it	REST API and webhooks. No plugin system, which is an explicit non-goal	REST API plus a plugin system added in v0.146.0	Not documented publicly

The G-code question decides most of this

If you slice the same model repeatedly, this is the row that matters, and the three tools answer it in three different ways.

PrintStash treats a sliced file as a revision of the model rather than as a separate item. Each revision carries a label, notes, the settings parsed out of the file, and an outcome: needs_test, known_good, failed, or archived. Exactly one revision is marked recommended, and the first G-code you add claims that marker automatically, so the model page always answers “which one was good” with one file instead of four candidates. Selecting two revisions shows their parsed slicer, material, and print settings side by side, which is how you find the nozzle swap or temperature change that fixed a corner lift.

Manyfold indexes G-code and gives it a preview, and its supported-formats page lists GCode with both static and 3D preview. What it does not yet do is version those files for you. The features page lists a built-in version control system under Q4 2026, alongside a built-in slicer. Today you can store every slice and describe it in prose, but the library will not hold the outcome as structured state you can filter on.

STL Shelf does not handle G-code at all. Its README lists STL, 3MF, OBJ, and PLY, and there is no mention of slicer metadata or printer connections anywhere in its public documentation. Its versioning applies to design files: upload a corrected mesh and the previous one stays in the model’s history. For a designer iterating on geometry that is the right unit. For someone iterating on print settings it is the wrong one.

What happens after you pick a file

PrintStash keeps the printer inside the library. It ships five providers, and their capabilities differ enough that you should check the compatibility matrix before planning a workflow around one of them. Moonraker/Klipper is the stable path with live status, upload, optional start, remote file inventory, pause and resume and cancel, and print-history import. PrusaLink and OctoPrint are beta and cover upload plus remote inventory. Bambu LAN is beta with plain-text upload and opt-in start but no remote inventory. Elegoo Centauri is beta with status, controls, and starting a file already on the printer, because current firmware exposes no file API safe enough to build on. Measured filament and cost come back from Moonraker only; the other providers still record the job and fall back to slicer estimates.

Manyfold can send a pre-sliced GCODE or SL1 file to a printer once you have configured a local printer connection, using the OctoPrint, Moonraker, and other APIs. That is a handoff rather than a print loop: the file leaves the catalogue and the printer host takes over. If you already live in Mainsail or OctoPrint and only want the catalogue to stop being a dead end, the handoff is enough.

STL Shelf leaves the printer out entirely. You download the file and open it in a slicer like you would from a Downloads folder, except the file is easier to find and you can see which version you are taking.

Three different ideas of what a library is

PrintStash is built around a vault. Files are stored in a canonical location, hashed on ingest, and deduplicated, so the same STL arriving twice becomes one model with two linked files rather than two entries. That vault can be local disk, S3-compatible object storage, or a shared volume that indexes a folder you already have. Shared volumes are the interesting case for anyone with a NAS: PrintStash mirrors the folder structure, leaves the bytes where they are, writes new uploads back without overwriting existing paths, and never deletes source bytes when you remove a model or the volume itself.

Manyfold is built around the catalogue record. It wants to know who made a model, where it came from, what license it carries, what it relates to, and who is allowed to see it. It can pull metadata, images, and sometimes the files themselves from Cults3D, MyMiniFactory, and Thingiverse, though that sync is manually triggered today. ActivityPub is the part nothing else in this comparison has: an instance can publish models, follow remote ones, and push updates to Mastodon followers. If you think of your collection as something with an audience, that changes the shape of the tool you want.

STL Shelf is built around the model page: versions, previews, tags, search, and organization-scoped access, on a deliberately narrow surface. The stack is modern and opinionated: TanStack Start on React 19, Bun, Postgres with Drizzle, Three.js previews, Better Auth for login. Object storage is required rather than optional, which is a real constraint if your files currently live on a NAS share and you would rather not move them into a bucket.

Getting each one running

None of these is hard to install if Docker already works on the host, but the shapes differ.

PrintStash is a Compose stack that pulls prebuilt images from GHCR. Download docker-compose.yml and run docker compose up -d; there is no clone and nothing to edit first, since every variable has a working default and the API generates its own signing secret on first boot. The first run wants a setup token that the API writes to its log. You get an API container and a frontend container, SQLite and local disk by default, and a setup wizard at /setup for the first admin account. There is no bundled default login. Postgres, S3, and a hardened Compose file that keeps the API internal are all available when you need them. Images are published for amd64 and arm64, so a Pi 5 or an ARM NAS works, and since v0.12.0 STEP previews generate on ARM too rather than only on amd64.

Manyfold is a Rails application with Docker Compose instructions, Postgres for production, and a longer running history than either of the others. It is at v0.147.0 as of late July 2026, having shipped releases steadily for years, and it is funded partly through NGI0 Entrust. That track record is worth something when you are choosing where to keep metadata you will spend months entering.

STL Shelf asks for more moving parts before first launch: Postgres 14 or newer, Bun 1.1 or newer, and an S3-compatible bucket with credentials. The repository ships a Compose file for local development. The tradeoff is that you can skip all of it and sign up for the hosted service, which is the only option here that lets you stop being a sysadmin.

Price, license, and what you owe later

PrintStash and Manyfold are both AGPL-3.0 and free to run, with no paid tier, seat count, or storage cap. Your costs are electricity, disk, and your own time.

STL Shelf is Apache 2.0 and free to self-host, but the hosted service is a commercial product. The free cloud tier is capped at 0.5 GB, 10 models, and one seat, which is a demo rather than a home for a library. Basic is $10.99 per month for 25 GB, 300 models, and one seat. Pro is $35.99 per month for 200 GB, unlimited models, and five seats, with 10 percent off for annual billing. The pricing page notes those limits apply to the cloud service only. If a small business wants someone else to hold the uptime pager, that is a fair trade. If you were going to self-host anyway, the license makes the plans irrelevant.

Ask the exit question before you commit to any of them. PrintStash exports models, files, metadata, taxonomy, print history, favorites, and saved views into a versioned archive, and its full backup includes the database, owned blobs, documents, thumbnails, and a manifest. Notably it does not copy source bytes that live on a shared volume, because those are still your files on your NAS. Check the equivalent path on whichever tool you choose, and check it before you have entered three thousand tags.

Who each one actually fits

A hobbyist with a few hundred models and one printer will be happy with any of the three, so pick on annoyance rather than features. If reslicing the same parts is your routine, PrintStash pays off first. If you download far more than you print and care about attribution, Manyfold does. If you want to stop running services, STL Shelf’s hosted tier does.

A print farm should look at PrintStash or Manyfold, and probably PrintStash. Fleet routing across configured printers with manual, default-printer, or least-busy selection shipped in v0.11.0, along with maintenance windows and soft-drain for taking a machine out of rotation. Those are new enough that real farm use is still shaping them, and the honest caveat is that scheduling does not score jobs by loaded filament color, nozzle, or plate compatibility, so an operator still makes those calls. What a farm gets in return is a record of which revision ran on which machine and what it consumed. The Klipper farm walkthrough covers how that fits with Mainsail.

A small business selling prints or working with clients has a different priority: someone else’s uptime. STL Shelf Pro is the only plan here with team seats and a vendor behind it. Manyfold’s fine-grained permissions and publishing suit a studio that shares work publicly. PrintStash fits when the business is manufacturing rather than publishing, and when you accept that hosting is your job. It is designed for trusted networks, so putting it on the open internet means TLS, a hardened reverse proxy, and real care about secrets.

There is one more option people forget: run two. Nothing stops Manyfold from cataloguing a NAS folder while PrintStash indexes the same folder as a shared volume, since neither moves the bytes. It is more maintenance and two sets of metadata to keep straight, but if you want federation and revision tracking, that is how you get both.

Questions that come up

What is the difference between PrintStash, Manyfold, and STL Shelf?

They optimize for different halves of the same job. PrintStash is a manufacturing record: source model, sliced revisions with parsed settings and outcomes, connected printers, print history, and cost. Manyfold is a catalogue: creators, licenses, sources, relationships, permissions, and ActivityPub publishing, with printer handoff through OctoPrint and Moonraker APIs. STL Shelf is a focused design library with versioned files, fast previews, tags, and team access, available as a hosted service or self-hosted under Apache 2.0. Ask which question you keep failing to answer: “who made this and can I share it”, or “which slice worked last time”.

Which one is best for a print farm?

PrintStash, with caveats. It is the only one of the three that connects to printers as first-class objects, queues G-code across a fleet with manual, default-printer, or least-busy routing, takes machines out of rotation through maintenance windows, and keeps job outcomes attached to the revision that produced them. The fleet queue shipped in v0.11.0 and is still maturing, and routing does not consider loaded filament or nozzle compatibility. Manyfold works for a farm that already has a dispatch layer and needs a catalogue beside it. STL Shelf has no printer features at all, so a farm would be pairing it with something else.

Which one has the best G-code tracking?

PrintStash, and the gap is wide rather than marginal. Revisions live on the source model, carry parsed slicer metadata, and hold an outcome you can filter on, with exactly one recommended revision per model. You can compare two revisions’ settings side by side, and a completed print can promote its revision to known good automatically without overwriting a manual failed or archived verdict. Manyfold stores and previews G-code but lists version control under Q4 2026, so today the history lives in your descriptions. STL Shelf versions design files and does not handle G-code.

Can I try all three for free?

Yes, though not on the same terms. PrintStash and Manyfold are AGPL-3.0 with no paid tier, so a Compose stack on any spare machine gives you the whole product. STL Shelf can be self-hosted under Apache 2.0 for free if you can supply Postgres, Bun, and an S3-compatible bucket, and its hosted plan has a free tier limited to 0.5 GB, 10 models, and one seat, which is enough to judge the interface but not to migrate into. Try each with the same twenty models, including one awkward multi-part project and several slices of the same part.

Can I keep my files on a NAS?

PrintStash and Manyfold both work with folders you already have. PrintStash adds the folder as a shared volume, hashes and indexes it in place, mirrors the structure, and writes new uploads back without overwriting anything. Removing a model or the whole volume leaves the source bytes untouched. Manyfold scans model folders on disk and supports S3 as well. STL Shelf expects files in an S3-compatible bucket, so a NAS share means running MinIO in front of it or copying the library into object storage. Anything that keeps other tools working on the same paths is worth preferring.

Which is easiest to get running?

The hosted STL Shelf plan, because there is nothing to run. Among the self-hosted options, PrintStash asks for the least: prebuilt images, two containers, SQLite and local disk by default, one secret to set, and a setup wizard for the first admin account. Manyfold is comparable if you are comfortable with a Rails app and Postgres. Self-hosted STL Shelf needs the most assembly, since Postgres, Bun, and bucket credentials are all prerequisites rather than defaults. None of them takes an afternoon, but the number of things that can be misconfigured differs.

Do any of them slice for me?

No. All three assume you slice in OrcaSlicer, PrusaSlicer, Bambu Studio, Cura, or similar, and they organize what comes out. Manyfold lists a built-in slicer on its Q4 2026 roadmap, which would make it the first of the three to try. PrintStash explicitly is not a slicer and does not intend to become one; its G-code viewer is a browser-side visualization, useful for checking a toolpath but not a simulator, and it will not validate firmware macros, acceleration, or pressure advance. Treat all three as filing systems around your slicer, not replacements for it.

What if I want federation and revision tracking?

Then you either compromise or run both, because no single tool in this comparison does both today. Manyfold is the only one with ActivityPub, and its version control is roadmapped for Q4 2026. PrintStash has the revision workflow and deliberately keeps sharing narrow, offering expiring read-only links rather than a public presence, and a plugin system is an explicit non-goal. Since neither tool needs to own the bytes, pointing both at the same NAS folder is workable. Decide first which one holds the metadata you would be upset to lose, and back that one up properly.

Sources

• Manyfold features, supported formats, integrations, and release news. Checked August 3, 2026.
• STL Shelf repository, about page, and pricing. Checked August 3, 2026.
• PrintStash capabilities, printer compatibility, core concepts, and known limitations.

For a wider field including GyroidVault, Makers Vault, and Printventory, read the 2026 self-hosted library roundup. For head-to-head detail, see PrintStash vs Manyfold and PrintStash vs STL Shelf. The alternatives overview sorts libraries from monitoring, remote-access, and farm tools.