Term Definition is a plugin that lets you mark a word, phrase, or math/code notation as a term, insert references to it anywhere else in a note, jump back to it with a tap, and rename it — every reference updates automatically.

https://reddit.com/link/1vieh3o/video/km9wlji621ih1/player

Installing

1. Download term_definition.snplg directly: https://github.com/vincentaravantinos/supernote-symbol-definition/releases/latest/download/term_definition.snplg
2. On the device: Settings → Apps → Plugins → Add Plugin, pick the downloaded file, Install.

Using it

Define and reference terms

• Lasso any handwriting and press (Re)Define Term to turn it into a term. A ≝ marker and underline appear next to it, and it becomes available everywhere in the note.
• Press Insert Reference to pick any defined term from a preview picker and insert a copy of its ink, underlined, at the current page. Tapping a reference jumps straight to its term, with a spotlight highlighting it on arrival.
• Tapping a term's own ink directly shows the same spotlight, without navigating anywhere, since you're already there.

Redefine a term

• Lasso a term's ≝ marker together with new ink (freshly written, some/all of the old ink kept, or a mix) and press (Re)Define Term again to change what a term looks like. Every reference across the whole note updates to match — this can take a while on a big note with many references.

Assign a definition

• Lasso a term's ≝ marker together with explanatory ink and press Assign Definition to attach a definition, kept distinct from the term's own identifying ink. Tapping a reference or the term itself spotlights both the term and its definition together. Redefining a term's own ink never disturbs its assigned definition, or vice versa.

Orphaned references

• If a term's ink is erased by hand, its remaining references become "orphaned." Tapping one explains that the term no longer exists and marks it with a ⚠.
• Find Orphans scans the whole note at once, marks every orphan, and generates a report page grouped by term (with an ink preview per group) — tap any entry to jump straight to it.
• Lasso one of an orphaned term's own references and press (Re)Define Term to recover it: recreates the term from a copy of that reference's own ink, instead of requiring anything to be drawn from scratch, and clears every reference's orphan status at once.

Find usages

• Lasso a term's own ink (with or without its ≝ marker) and press Find Usages to generate a report of every reference to it across the note, with one tappable entry per usage.

Limitations

• Overall it can be pretty slow.
• Clearly we are pushing the limits of the plugin system here, there are many multi-page changes, many async modifications and interactions.
• Meaning it can often be a bit buggy. To fix misbehavior: try the Repair Terms button, or activate/deactivate the plugin (and worst case restart the device, but so far never was needed for me).

GitHub: https://github.com/vincentaravantinos/supernote-symbol-definition

u/Dunn-sn

Currently registerMotionListener forwards every single touch on screen — included toolbar, sidebar, menus — not just note content. The problem is that my plugins catch those touches as well but have no means to know that those touch events are not landing on the note itself. Then I start some code that does stuff assuming we're on the note but it fails in a way we can't control (typically navigating to another app or another note).

Proposal: add an opt-in scope to registerMotionListener, e.g. {noteContentOnly: true}, to receive only touches on the note itself.

PluginManager.registerEventListener / EventType currently only cover PEN_UP, IMPORT_STICKER, and MOTION_EVENT — there's no way for a plugin to observe the device's physical side button of the pen (press, release, or held state). Could you expose an EventType (or equivalent API) for it? Use case: gating a plugin action so it only fires while the side button is held, rather than always-on gesture detection (I would like this for the scribble plugin).

I just put out Collapse / Expand (folds a region of handwriting behind a + icon, brings it back later). I post separately here particularly for fellow developers because I struggled on many things while developing the plugin and I think many of the struggles might be shared by other developers so I thought I'd share it here so it may help people.

• If you need persistent, reversible state tied to page content The collapsed/expanded/recollapsed state machine lives entirely inside the .note file via element userData — no sidecar files, no app-memory state, survives power-off/restart/reload. If you need durable state that travels with the note itself, this is a working example of the .note as your database.
• If you need to find/manage "your" elements on a shared page Each element the plugin owns carries a userData prefix (icon / restored-content / mask / frame), so the plugin can locate and clean up exactly its own elements without touching the user's content or other plugins' data (userData is isolated per plugin).
• If you need to round-trip arbitrary content, including links Strokes (points + pressure + EMR coords), text, geometry, and handwritten "stroke" links all survive a full delete-and-reinsert cycle as working links — including re-resolving a stroke link's member references after re-insertion assigns new page-nums, which is the fiddly part.
• If you need progress feedback during a long operation Native dialogs are blocking modals, so they can't show progress. This plugin renders its own transient "working…" overlay via showPluginView/closePluginView around a headless operation — a pattern you can lift directly.
• If you need gesture-driven live updates (drag-to-resize, etc.) The motion listener gives you coordinates only, no element identity. This plugin shows how to correlate touch with element rects, distinguish a move from a lasso-select starting at the same spot, and "read before dismiss" so you don't clobber the user's active selection.

Other things this code already handles, documented in SDK_DOC.md

• The cached-vs-real .note split (getElements reads a cache; insert/deleteElements write the real file) and the reloadFile / no-saveCurrentNote-after-write pattern that keeps them in sync.

• Always dismissing a programmatic lasso (setLassoBoxState(2)) after mutating, to avoid a trail-cache leak that eventually breaks insert/delete.

• Minimizing element I/O cost — getElementNumList vs getElements, and batching writes since each write call costs roughly the same regardless of payload size.

• Driving deferred work off input events instead of setTimeout/setInterval, which don't fire while the plugin is idle.

• Faking filled/dashed shapes with the SDK's outline-only geometry and limited pen palette.

• Working around modifyElements corrupting non-icon geometry when only userData should change.

  Happy to answer questions, and if you're solving something adjacent, feel free to borrow whatever's useful from the code or SDK_DOC.md (and if you have better ideas please let me know!!!)

Repo here: https://github.com/vincentaravantinos/supernote-collapse-expand

u/Dunn-sn also maybe relevant for you to see how I might abuse some things in the SDK...

I see many people posting videos of their plugins as GIFs - how do you do that?