Language SDKs for building native Owncast plugins
Repo owncast/plugin-sdk, read from GitHub 2 d ago. owncast has not joined Take My Repo.
owncast/plugin-sdk is a public repo on GitHub by owncast. Language SDKs for building native Owncast plugins. It declares the MIT license on GitHub. It is written mainly in Go, has 2 stars and last changed on 2026-10-11. Nobody has reviewed it on Take My Repo yet, which says nothing about its quality. Read from GitHub on 2026-11-20.
In the maintainer's words. Shown from GitHub; Take My Repo does not keep a copy.
An in-process plugin system for Owncast: JavaScript and Python plugins that ship as source and run on language engines embedded inside a Go host via Extism (which uses Wazero, pure Go, no CGo).
This isn't part of Owncast yet. It's a sandbox to validate the architecture.
Layout mirrors the planned future repo split: sdks/<lang>/ for author-facing SDKs that ship to package managers, tools/ for binaries shipped via GitHub releases, host-runtime/ for the host code that will eventually move into the Owncast server repo.
.
├── sdks/
│ └── js/ @owncast/plugin-sdk, npm package for authors
│ ├── index.js runtime: definePlugin(), host.* wrappers
│ ├── index.d.ts TypeScript types for editor autocomplete
│ ├── bin/ owncast-plugin build CLI
│ ├── scripts/ postinstall fetches extism-js + binaryen
│ └── create-owncast-plugin/ scaffolder (`npx create-owncast-plugin@latest`)
│
├── host-runtime/ Go: PoC host runtime, moves to the Owncast server
│ │ repo when integration lands
│ ├── plugin/ runtime library: manager, dispatcher, server, host-fns
│ │ └── testing/ scenario runner used by the test binary
│ ├── kv/ Store interface + bbolt and in-memory impls
│ ├── cmd/owncast-plugin-test/ standalone test runner CLI
│ ├── cmd/owncast-plugin-serve/ localhost dev HTTP server CLI
│ └── main.go demo: simulated chat stream against the runtime
│
├── examples/
│ └── js/ one JS example per architectural feature (see below)
├── plugins/ .ocpkg packages the demo host loads (build artifacts, gitignored)
├── tools/ prebuilt extism-js, wasm-merge, wasm-opt, Go binaries
└── docs/ guides + wire protocol + roadmap
plugin.manifest.json declares display name, slug (the canonical identifier), version, subscriptions (notify/filter), and permissions. The host compares it against the plugin's runtime register() output at load; mismatches on slug, version, or permissions are rejected.onEvent(event) with a string switch, plugins define methods like onChatMessage(msg) and filterChatMessage(msg). The SDK derives the manifest's subscriptions from which methods are present, so the author maintains a single source of truth.on: { ... } for custom events, declare local hook names such as
"announcement.broadcast". The host owns the fully qualified
<plugin-slug>.<hook> subscription. Emitters target that name.on* handlers, fire-and-forget, plugins run in parallelfilter* handlers, sequential, priority-ordered, return filter.pass() / .modify(payload) / .drop(reason). Errors fail open.owncast.chat.send, owncast.kv.{get,set}, owncast.events.emit, owncast.http.fetch, gated by declared permissions. For HTTP, the manifest must declare network.fetch AND network.allowedHosts (a list of hostname globs); the host wires those straight into Extism's AllowedHosts. The wildcard "*" is permitted but must be written explicitly so the manifest reflects the granted scope./plugins/<slug>/*, static assets are served directly; unmatched paths fall through to the plugin's onHttpRequest(req) handler. Requires http.serve permission. Default-public; gate admin-only features on req.authenticated. Response headers are filtered through an allowlist (no Set-Cookie etc.); request and response bodies are size-capped.<slug>.wasm + <slug>.manifest.json + optional <slug>-assets/ dropped into plugins/. Easy to inspect and iterate during dev..ocpkg packages, bundling plugin.manifest.json + the compiled plugin + optional assets/ into one file. Built via owncast-plugin package. The admin uploads it from the Plugins page (or drops it into data/plugins/) and enables it. Recommended for distribution.owncast.events.emit(type, payload), the emitted event re-enters the dispatcher and fans out to subscribers. Recursion is capped at MaxEmitDepth = 8.plugins.kv.<slug>. in Owncast's datastore; plugins can't read each other's keys. (The PoC host-runtime/kv/ package ships bbolt + in-memory impls for the standalone demo binary, the real Owncast host wires datastoreKVStore instead.)# Build the Go-side binaries this repo owns (one-time, after cloning)
tools/bootstrap.sh
# Build each example into ./plugins/ (the build just bundles each plugin's
# source; no wasm toolchain is needed)
for ex in examples/js/*/; do tools/build-plugin.sh "$ex"; done
# Run the simulated chat stream
cd host-runtime && go run . ../plugins
tools/bootstrap.sh compiles owncast-plugin-test and owncast-plugin-serve from host-runtime/cmd/. End users installing the published SDK get these as per-platform release-asset downloads via the postinstall instead, bootstrap.sh is for repo developers running against a not-yet-released checkout.
You should see the chat stream flow through the filter chain (slow-mode, buggy-filter, profanity-filter), then fan out to notification subscribers (chat-logger, echo-bot, message-counter, relay), with relay targeting announcer's announcer.announcement.broadcast hook.
for ex in examples/js/*/ examples/python/*/; do tools/owncast-plugin-test "$ex"; done
Or cd examples/js/<slug> && npm test (JS) / owncast-plugin-py test examples/python/<slug> (Python) for a single plugin, which rebuilds it first.
JavaScript:
npx create-owncast-plugin@latest my-plugin
cd my-plugin
npm install # postinstall fetches the prebuilt test/serve host binaries
npm run build # bundles src/plugin.{js,ts} into my-plugin.js
npm test # builds, then runs scenario tests in __tests__/
npm run serve # localhost dev server at http://localhost:8080/plugins/my-plugin/
npm run package # produces my-plugin.ocpkg, single-file distributable
Python:
uvx owncast-plugin-py new my-plugin # scaffold ./my-plugin, no install
cd my-plugin
uv tool install owncast-plugin-py # or: pip install owncast-plugin-py
owncast-plugin-py build my-plugin # emit src/plugin.py -> <slug>.py
owncast-plugin-py test my-plugin # run the __tests__/ scenarios
owncast-plugin-py serve my-plugin # local dev server (POST /_dev/chat to drive it)
owncast-plugin-py package my-plugin # build + bundle -> <slug>.ocpkg, single-file distributable
Plugins ship as source and run on a language engine the host embeds, so there's no wasm compile step or toolchain to install for authoring. Author code goes in src/plugin.js (or src/plugin.py). Edit plugin.manifest.json to declare permissions (subscriptions are derived from your handler methods). The TypeScript declarations in @owncast/plugin-sdk give editor autocomplete. Static assets, HTML pages, images, JS, go in assets/; they're served at /plugins/<slug>/.... See the Python SDK for the Python-specific authoring details.
Plugins are tested against the actual built artifact using the same plugin runtime code that the production Owncast app uses, so passing tests guarantee the same code path passes in production. No Owncast restart, no live stream needed.
Tests are JSON scenarios in __tests__/*.test.json:
[
{
"name": "echoes the message back",
"events": [
{
"event": "chat.message.received",
"payload": { "user": { "id": "u-alice", "displayName": "alice" }, "body": "hi" }
}
],
"expect": { "chatSends": ["alice said: hi"] }
},
{
"name": "rate-limits same user within 2s",
"given": { "kv": { "last:u-alice": "1704067200000" } },
"events": [
{
"filter": "chat.message.received",
"payload": {
"user": { "id": "u-alice", "displayName": "alice" },
"body": "spam",
"timestamp": "2024-01-01T00:00:01Z"
},
"expect": { "action": "drop", "reason": "/slow-mode/" }
}
]
}
]
Available step types:
event: "<type>", fire-and-forget notification dispatchfilter: "<type>", filter chain; inline expect: {action, payload?, reason?}http: { method, path, headers, body, expect: {status, headers?, body?} }, sends request through the same plugin.Server production usesAvailable assertions:
expect.action / expect.payload / expect.reason for filter steps; http.expect for HTTP stepsexpect.chatSends (exact list), expect.emits (exact list of {eventType, payload}), expect.kv (partial map), expect.httpRequests (outbound HTTP from the plugin)given.kv (initial plugin-config namespace), given.httpResponses (canned HTTP responses for outbound owncast.http.fetch calls)The runner is the owncast-plugin-test binary. For JS plugins, npm test invokes it via the SDK CLI. Non-JS plugin authors install the binary directly.
Minimum plugin:
const { definePlugin, owncast, filter } = require("@owncast/plugin-sdk");
module.exports = definePlugin({
// Notification handler, typed payload, no string switching.
onChatMessage(msg) {
owncast.chat.send(`echo: ${msg.body}`);
},
// Filter handler, return filter.pass() / .modify() / .drop().
filterChatMessage(msg) {
return msg.body.includes("spam") ? filter.drop("spam") : filter.pass();
},
// Local custom hook, owned as <your-slug>.announcement.broadcast.
on: {
"announcement.broadcast"(payload) {
console.log(`announcement from ${payload.by}: ${payload.text}`);
},
},
});
See examples/js/README.md for the full catalog of plugin examples with one-line summaries. Each example has its own README inside its directory.
host-runtime/ is PoC scaffolding. The real home is the Owncast server repo; the wire interface in docs/WIRE_PROTOCOL.md is the contract between the two repos.host-runtime/go.mod still
pins an Owncast build that keeps custom subscriptions literal. The CI workflow
tests this branch against the matching Owncast branch, but the pin must move
to the released runtime before this SDK change merges.<pluginsDir>/.enabled.json for the PoC's standalone demo binary. Owncast already wires a config-store-backed implementation; the file-backed default exists only for the demo.manifest.config schema is parsed but no host function exposes config values to plugin code. Intent is typed config values per plugin, editable from the Owncast admin UI (today plugins persist their own state via owncast.kv.{get,set}).onChatMessage keeps getting called forever.html field ship the HTML verbatim. The Owncast frontend renders trusted external-action HTML today; once these come from plugins, server-side sanitization (or a tighter allowlist) is worth considering.sdks/go/ and sdks/python/ are planned. They'll implement the same wire protocol and consume the shared scenario test corpus and release binaries..js directly. Today the build step is mandatory.owncast/plugin-sdk is a public repo on GitHub by owncast. Language SDKs for building native Owncast plugins.
It declares the MIT license on GitHub.
Its maker has not tagged a system, so it is unknown here. Its README says what it needs.
Open "Take it" on its page: Take My Repo writes an install plan for your machine and hands it to your AI agent (Claude Code, Codex or Cursor), which asks you before each step. Take My Repo has not tested it on any machine.
Its last change on GitHub was on 2026-10-11. Take My Repo does not judge from that whether it is maintained.
Nobody has reviewed it on Take My Repo yet, which says nothing about its quality.
Warp is an agentic development environment, born out of the terminal.

Explore radio, live TV, podcasts, films and public archives from 10 sources. Import M3U, PLS, XSPF, JSON and CSV playlists, organize favorites, fine-tune with EQ, download and record in one portable player.
Fullstack app framework for web, desktop, and mobile.
Take control over your live stream video by running it yourself. Streaming + chat out of the box.

An example of a 24/7 stream powered by Owncast + ffplayout
A Roku channel application for browsing the directory and viewing Owncast-powered streams
Attempt to minimize latency when using videojs http streaming.