threejs-stage

Live three.js r187 scenes and GLB, GLTF, STL and OBJ models in Hermes chat. Hermes calls one tool, three_scene, with scene code or a model file. Hermes Desktop draws the result as an interactive card with orbit, zoom, fullscreen, restart, screenshot and Ask Hermes to change this, and other surfaces get a standalone HTML file. With Desktop open, each scene is dry-run in a hidden frame before the tool returns, so a crash or a blank render reaches Hermes in the same turn. Disclosure — scene code written by the model runs in Desktop inside a sandboxed iframe (opaque origin, scripts only) whose content security policy blocks all network requests; three.js r187 is bundled (MIT). The exported HTML file loads three.js from cdn.jsdelivr.net when opened in a browser. Given a model path, the tool reads that file and the .bin, .mtl and image files it references in the same folder (50 MB limit) and copies them to plugin storage; scenes, screenshots and delivered files are stored under plugin-data/threejs-stage and cache/generated/threejs-stage on this machine. The dry run makes the tool wait up to 2.5 s for Desktop and up to 16 s for the result, and can be turned off (verify_scenes). Fix with Hermes and Ask Hermes to change this each send one ordinary chat message. No API keys, no telemetry, no background processes, no self-update.

tuancookiez-hubDesktopv0.1.0Updated 25 minutes ago

About

Three.js Stage

Live three.js r187 scenes and 3D models in Hermes chat.

Ask Hermes for anything 3D, like "show me a double pendulum", "visualise this point cloud" or
"a low-poly island at sunset". Hermes writes a scene and calls three_scene. In Hermes Desktop
the reply contains a live card you can orbit, restart, expand to fill the Hermes window, and
screenshot. If the scene breaks, the card shows the error with the failing line, and Fix with Hermes sends it back so
Hermes can repair it. Ask Hermes to change this sends a follow-up request about that scene.

It also shows model files. Ask "show me C:/models/robot.glb" and you get the same card, with
the model lit, framed and animated, plus its format, triangle, mesh and animation counts. GLB,
GLTF, STL and OBJ are supported, including .bin, .mtl and texture files beside the model.

Outside Desktop (CLI, TUI, messaging), the same call delivers a standalone .html file that runs
the scene in any browser.

A three_scene card in Hermes Desktop

Using the card

Drag to orbit, right-drag to pan. The mouse wheel scrolls the chat until you click the
scene; after that it zooms, until the pointer leaves the card. In fullscreen it always zooms.
Restart runs the scene again from the start. Fullscreen fills the Hermes window
(Escape leaves). Screenshot saves a PNG on the machine Hermes runs on and shows its path.
Ask Hermes to change this opens a box for a follow-up such as "make it night and add fog".
Cards stop rendering when scrolled off screen, and after 30 seconds off screen they release
their GPU context. They start again when you scroll back.

Hermes checks its own work

With Desktop open, every three_scene call runs the scene for one simulated second in a hidden
sandboxed frame before the tool returns. If it crashes, Hermes gets the error and the failing line
in the same turn and repairs it, so you never see the broken version. If it runs but draws nothing
or comes out black, Hermes is told that too. A prompt or skill alone can't do this, because the
model can't see what its own code does on a real GPU.

What's in the package

| Part | What it does |
|---|---|
| three_scene tool | Statically checks the scene against the r187 contract (imports, renderer misuse, GLSL, storage, loop ownership) and validates model files. It rejects problems in the same turn, stores the scene, and returns a MEDIA: line. |
| threejs-stage:three-r187 skill | The scene contract, the WebGL2-vs-WebGPU rules, bundled addons, and recipes (environment lighting, shadows, instancing, bloom, TSL materials). |
| Desktop card | A tool media renderer for three_scene. It runs the scene in a SandboxedFrame whose content security policy blocks network access, and pauses rendering when scrolled out of view. |
| Backend (dashboard/plugin_api.py) | Serves the vendored three.js r187 to the card, serves scene records and stored models (by scene id, never by path), and saves screenshots. |

Requirements and install

Hermes >= 0.22.7. The card needs a Desktop build with tool media renderers.
hermes plugins install threejs-stage, then enable it for the profile
(hermes plugins enable threejs-stage) and turn on its Desktop half in Capabilities → Plugins.
Restart the gateway once after installing, so the plugin's backend routes are mounted.

Disclosures

Code execution. Scene code written by the model runs in Hermes Desktop inside a sandboxed
iframe (allow-scripts allow-pointer-lock, opaque origin). It cannot reach the app, its
storage, cookies or the native bridge. It runs on your GPU, so a heavy scene can use
noticeable GPU and CPU while visible. Cards pause when scrolled off screen.
Network. The Desktop card cannot use the network. three.js comes from this plugin's own
backend, and the frame's content security policy (default-src 'none', with only blob: and
data: sources allowed) blocks every request scene code could make. The exported .html file
is different: it loads three.js 0.187.0 from cdn.jsdelivr.net when you open it in a browser,
and has no such policy.
Files read and written. When Hermes passes a model path, the tool reads that file and the
.bin, .mtl and image files it references. References that leave the model's folder are
refused. It copies them to <HERMES_HOME>/plugin-data/threejs-stage/models/. Scene records go to
.../plugin-data/threejs-stage/scenes/, screenshots to .../plugin-data/threejs-stage/screenshots/,
and delivered files to <HERMES_HOME>/cache/generated/threejs-stage/. Nothing is deleted
automatically; these folders are safe to clear, at the cost of old cards no longer reopening.
Hidden dry runs. With Desktop open, each three_scene call runs the scene briefly in a
hidden sandboxed frame. The tool waits up to 2.5 seconds for Desktop to pick it up, and up to
16 more for the result. Each automatic repair is a normal model call and uses tokens. Turn this
off with the verify_scenes setting.
Cost. No API keys, no paid services, no telemetry, no background processes. Fix with
Hermes and Ask Hermes to change this each send one ordinary chat message, which uses
model tokens like any message you type.

Model limits

50 MB total per model. Above 25 MB, non-Desktop surfaces get the model file itself rather than
an HTML viewer.
Draco, meshopt and KTX2/Basis compressed glTF files are refused, because their decoders are
binaries this package does not ship. Export without compression.
OBJ uses the first .mtl file it references. Textures must be PNG, JPEG or WebP.

WebGPU vs WebGL2

SandboxedFrame documents with a data: URL are not a secure context, so navigator.gpu is
absent and WebGPURenderer runs on its WebGL2 backend. The card shows which backend is in use.
On WebGL2, TSL atomics silently return 0 and storage textures throw. The skill tells Hermes to
guard both. Measurements are in probe/RESULTS.md.

Development

node scripts/vendor-three.mjs <unpacked three@0.187.0 package>   # refresh vendor/three
node scripts/build.mjs                                            # desktop/src → desktop/plugin.js
hermes plugins doctor . && hermes plugins validate .

License

README from the reviewed commit 5dbee69; it updates when the author re-pins.

More by tuancookiez-hub

8 plugins by tuancookiez-hub in the catalog.

tuancookiez-hubhyatlasHyAtlas 5 — self-hosted 8-layer memory provider backed by a pure-Go single-binary server you run yourself (chromem-go vectors, in-process BGE-small embeddings, hybrid vector + keyword search, bitemporal knowledge graph with source citations). Embeddings, the vector index and stored memories are kept locally. Ships agent tools (hyatlas_status/search/recent/add), a `hermes hyatlas` CLI, a Desktop pane with a starmap graph view, and a web dashboard. Disclosure — requires the separate hyatlas-go server, installed by the user. The plugin never downloads or bundles it, and it talks only to the configured server (default 127.0.0.1:19528). Embeddings are computed locally; stored memories leave the machine only in the LLM calls described below. Extraction is opt-in and uses an LLM you choose: `hermes memory setup` asks for any OpenAI-compatible endpoint, model and key, and stores the key in Hermes's .env as HYATLAS_LLM_KEY. The plugin reads that key only through Hermes's get_secret and reads no Hermes credential. A plain key file named by HYATLAS_LLM_KEY_FILE also works; the server reads it on every call, so do not point it at another program's credentials such as Hermes auth.json. The server has no default endpoint and makes no LLM call until the endpoint, the model and a key are all present; while the endpoint and model are set but no key has arrived, /api/v1/status reports llm "awaiting_key". `hermes memory setup`, the repo installer and the sample launcher pre-fill a free Nous Portal endpoint and model (and setup defaults to ultra mode), but nothing is sent until a key is supplied. A server the plugin starts gets that key in its environment; for a server started another way (the launcher, a service) that reports "awaiting_key", the plugin (at most every 10 minutes) and `hermes hyatlas doctor` POST the key over plain HTTP to /api/v1/llm/key, only when the configured server host is this machine; the server accepts it only from a loopback address and keeps it in memory only, never on disk. Once configured, each turn's user and assistant text goes to that endpoint (not tool output or context summaries; capped at 12,000 characters), together with up to 5 related stored facts, 3 entity pages and 5 open intentions of that owner so the model can update them instead of duplicating them. In the default ultra mode the server also sends topic-grouped batches of up to 50 stored facts to it every 6 hours (every 20 minutes while earlier batches are still pending) and supersedes (hides but keeps) the facts the model marks merged or stale, recording a reason for each drop. It also records relations corroborated across turns in the local knowledge graph (HYATLAS_CONSOLIDATE_GRAPH=off disables that). Once a day per owner (HYATLAS_CROSS_SCHEMA_EVERY; off disables it) ultra also sends up to 40 of that owner's stored patterns to find up to 3 that hold across topics. In pro and ultra modes it also sends each owner's open intentions, recent summaries and newest facts to rewrite a short Now page, at most every 15 minutes (HYATLAS_NOW_EVERY), and, after a 30-minute pause in an owner's writes (HYATLAS_EPISODE_GAP; off disables it), up to 40 of that stretch's facts to write one episode summary. HYATLAS_RECONCILE=on (off by default) adds a second LLM call per write that sends the new facts together with similar stored ones (including those under user IDs grouped with the owner by HYATLAS_USER_ALIASES) so the model can update, replace or link them; it is meant for a local model. An optional HYATLAS_LLM_FALLBACK_MODEL, tried only when a primary call fails, receives the same text; it is sent the primary key only when it uses the same host. Turns written while the endpoint was unreachable or before a key arrived are extracted later by a catch-up pass (every 10 minutes by default, HYATLAS_CATCHUP_EVERY; rows up to 7 days old, HYATLAS_CATCHUP_MAX_AGE), sending the same text a write would have sent. `hermes hyatlas doctor` sends one short test prompt ("Reply with the single word OK.") to the endpoint and writes, finds and deletes one test memory. When you replace or remove an entry with Hermes's memory tool, the plugin asks the local server to retire the matching memory (reversible); nothing leaves the machine. HYATLAS_MODE=lite makes no LLM call. Server endpoints that rewrite stored data are off unless the server runs with HYATLAS_ADMIN=on. The spawned server gets an allowlisted environment (OS essentials plus HYATLAS_*), not the agent's keys. auto_start is off by default; when on, Hermes starts the server as soon as it loads the plugin, and a server started by auto_start or `hermes hyatlas start` keeps running after Hermes exits until `hermes hyatlas stop`. On Windows, if a hyatlas-go.ps1 launcher is configured, `hermes hyatlas start/stop` runs it; the repo's sample launcher reads no credentials (since 4.8.0 it no longer reads Hermes auth.json). No telemetry.Communitymemory31 tuancookiez-hubenhance-promptA sparkle beside Send that rewrites the composer draft in place without sending it, deepening it into a clarifier, a task list, then a phased plan on further clicks, with a one-click discard back to the original. Also registers the `/enhance` slash command and the `enhance_prompt` tool for the same rewrite from the agent. Draft read and write go through `host.composer`, so `@file` and `/command` chips survive. Disclosure — every click runs one stateless `llm.oneshot` call on your own gateway with the focused chat's model (the auxiliary title model when no chat is focused), followed by a second short call to score the result, so it spends your model credits. It is not an agent turn: no tools run and nothing is written to a session you cannot see. It overrides no model, sends nothing to a third party, never sends the composer message, and carries no telemetry, no credentials and no self-update.CommunityDesktop app6 tuancookiez-hubdiscord-tpsShow live tokens-per-second and the active model on your Discord bot's presence. Disclosure — Replaces the Discord bot's public presence with the live tok/s figure and the model name of the most recent API call in this gateway (any platform or chat), visible to anyone who can see the bot; updates at most every interval seconds (minimum 10) over the gateway's existing Discord connection. Reads no credentials and makes no network calls of its own.Communityplatform1 tuancookiez-hubmodel-explainerA Models page for Hermes Desktop built around your own model picker: choose a model to see its Hermes Index score, cost per task, context and output limits, price, abilities and your own measured speed and spend, with a score-against-cost frontier chart, and compare up to four side by side. Every value cites a source and date. Disclosure — one GET of a public JSON data file from the author's GitHub repo (raw.githubusercontent.com/tuancookiez-hub/hermes-model-explainer, main branch, so its contents can change after this pin), at most daily and only when the page opens (can be turned off; the bundled copy works offline; the file is validated data, never code); reads model.options and the focused session's model and usage figures; writes plugin storage, and switches the chat model only when the user presses Use this model (the same config.set request as the built-in picker, scoped to the open chat). Desktop only: no agent tools, hooks, middleware or env vars.Communitymodels1

All 8 by tuancookiez-hub

Developer Mode

Explore built-in Hermes toolsets and actions.

HermesAgent

Developer?

Create a Hermes extension for Desktop or agent workflows.

Developer Section