The quickest start is the example extension, prusa3d/prusa-connect-extension-example. It has both parts: a Go process that answers one route, and a browser bundle that adds one page to the Connect web app that calls it through a typed client. It also has the release workflow that publishes it here through the marketplace’s builder.
What you need
- Go 1.26
- Node.js 22.12 or newer, and pnpm 11
- git and make
The example builds against a checkout of
Prusa Connect: make core clones it into .core/.
The Go SDK and the npm packages come from that checkout until they are published on their own.
1. Copy the example
git clone https://github.com/prusa3d/prusa-connect-extension-example spools
cd spools
rm -rf .git && git init
Create a public repository for it on GitHub, for example acme/spools, and push it there. The
builder that publishes it records a build provenance attestation, which GitHub records only for
public repositories.
2. Give it your name
The module path is the extension’s identity, so set it before the first release. It never changes after that. Write your repository’s address in three places:
| File | What to change |
|---|---|
go.mod |
module github.com/acme/spools |
faults.go |
mustDomain("com.github.aux.acme.spools"), the id derived from that path |
module.yaml |
name: spools, plus title, summary, codeowner and license |
name also names the binaries, such as spools_linux_arm64. title and summary are what
operators read here and in Settings → Extensions, so write them for an operator, not for a
developer, and as plain text: control and invisible characters are refused.
3. Build and test
make check # Go vet and tests, then the bundle's lint, types and build
make release # the release directory, in release/
release/ holds module.yaml, one binary for each platform under platforms: in
module.yaml, and the bundle under ui/. Remove a platform from that list if you do not want to
ship it. It is for trying the extension yourself: a release published here is built by the
marketplace’s builder from your source, not from this directory.
4. Try it on your own server
make install
This installs release/ into a small server under bin/try and prints the command that starts
it. Open the address it prints, sign in, and the extension’s page is in the sidebar.
To work on the page with live reload, run pnpm dev in ui/. It serves the Connect web app with
your bundle in it, against the server in PCL_CORE_URL (http://localhost:8080 by default).
5. Before the first release
-
The license.
licenseinmodule.yamlis required: the license the extension is under, such aslicense: MIT. The example starts with MIT; change it to yours. Operators read it on the extension’s page here before they install it, and a release without it is refused. -
The version.
versioninmodule.yamlis the release’s version. Raise it for every release, and add the same version toCHANGELOG.md. -
The Connect versions it supports.
require.coreinmodule.yamlis a range such as">=0.1.0-beta.1". A server outside the range is not offered the release. Raise it when you build against a newer Prusa Connect. -
Permissions. List under
permissions:only what the extension really needs. The reviewer and every operator read that list before they accept it. -
Connections outside Prusa Connect. Declare each one under
egress:: the host (or the option in which the operator sets it), the ports, why, and what it sends. Operators see the list on the extension’s page and in the install dialog. The marketplace reads your source for every outbound call, from the Go program and from the browser, refuses a release that makes oneegressdoes not declare, and holds each declared one to itswhyandsends.egress: - host: api.github.com why: Checks for a newer PrusaSlicer release sends: Nothing but the request for the release list - option: printer_url # the host the operator sets in this option from: process why: Sends finished jobs to the operator's print server sends: The G-code and the job's name
Learn more
The Prusa Connect documentation explains everything an extension can do:
- Write your first module: the Go SDK step by step.
- Writing a service module:
module.yaml, records, events, settings and the limits the server enforces. - Styling a module: the browser bundle and its styles.
When it works, publish it from GitHub Actions.