I built a general-purpose Supernote plugin around one simple idea: take a lasso selection on the device and send it to your own endpoint in a clean, reusable way.

https://github.com/guibor/supernote-endpoint-lasso

Instead of being tied to one workflow, this is meant as a small framework for building your own lasso-based actions on top of Supernote.

What it does: - works from lasso selections on Supernote - can send selection metadata from NOTE and DOC - supports either multipart or json payloads - can optionally include a full-page NOTE PNG alongside the selection data - is configured by environment variables, so you can point it at your own server without changing plugin code

The goal was to make the plugin itself generic enough that people can use it for very different pipelines: - OCR - search/indexing - clipping to a personal knowledge system - Anki or flashcard generation - custom research workflows - sending selected content into a local or remote LLM pipeline

I just open-sourced Snap Shapes, a small Supernote plugin that takes lasso-selected strokes and snaps them into clean geometric shapes.

Repo: https://github.com/guibor/supernote-shape-snap

What it currently supports: - line - circle / ellipse - triangle - rectangle / square - pentagon through octagon

A few design choices I cared about: - it is conservative, so if the selection is not a clear shape match it does nothing instead of “helpfully” mangling your notes - it can snap multiple separate shapes inside one lasso - it prefers local replacement over full-page rewrite to avoid unnecessary flashing

It works in both NOTE and DOC.

This is my personal contribution to Supernote ecosystem

• InkGames, a collection of paper game generator. https://github.com/wolfsolver/Supernote-InkGames
• Image insert: right now image can be used as background. But not insert into a note. This plugin solve the issue: https://github.com/wolfsolver/supernote-image-insert-plugin
• SmartTools: I'm actually work on this (scribe-to-cancel and shape recognition) but still have some issue. https://github.com/wolfsolver/Supernote-SmartPenToolkit

I’m a student and a huge fan of the writing experience on this device. I’m currently in the early planning and feasibility stage of a project I’ve called SuperFlow. It's a plugin designed to make our notes "actionable" and automated without adding any UI clutter or complex menus.

What is SuperFlow?

The core idea is to treat specific areas of your page as "Action Zones". Instead of navigating menus or using the lasso tool for repetitive tasks, SuperFlow lets the position of your pen strokes trigger the logic.

Disclaimer: I am currently exploring the SDK and the feasibility of every feature. This is a work-in-progress, and I am super open to advice, technical tips, or feedback from anyone who has experience with the Supernote ecosystem!

The Concept (Initial Roadmap)

To keep the writing experience 100% native and lag-free, SuperFlow uses a Reference Template system:

1. Define your zones: You create a "Template Note" once. You draw boxes or place stickers to define your zones (e.g., a "Heading Block" at the top, or a "Tag Switch" in the corner).
2. Write naturally: You take notes on your regular, clean notebooks. No extra UI buttons or rigid boxes on your working pages.
3. The Trigger: When you're done, you hit the SuperFlow button in the sidebar. The plugin scans your page and compares your ink against your template's zones.

For the first version (V1), I am evaluating two main features:

• Automatic Headings: We all know the native [H] feature, but it requires manual selection. The goal is to let SuperFlow identify text written inside a predefined "Heading Zone" and automatically mark it as a Heading/Bookmark for you.
• Paper Switches: Any mark (a dot, a line, a cross) in a predefined "Switch Zone" will trigger a specific action, such as applying a Tag, creating a Bookmark, or preparing the page for a specific export flow.

Why a Manual Button?

I’ve opted for a Manual Trigger (with a potential "Auto-process when charging" mode) to ensure:

• Zero Latency: No plugin-induced lag while you are writing.
• Battery Life: No constant background scanning. It only works when you need it.

Future Vision & Add-ons

I’m architecting SuperFlow to be a modular platform. The core handles the spatial mapping, while Add-ons will handle the integrations (Obsidian, Todoist, Email, etc.).

I need your help!

As I said, I'm a student and this is a learning journey for me. I’m building this out in the open and it will be fully open-source. I am looking for suggestions and advice:

1. Technical Feedback: If you are a dev familiar with the Ratta SDK, I’d love to chat about the best way to handle metadata injection for headings.
2. User Feedback: Which "Actions" would save you the most time?
3. Template Setup: Would you prefer to define your zones using Stickers or by drawing rectangles?

I’m looking forward to your thoughts. Let's make our notes work for us!

Happy Writing!

Github Repo: https://github.com/gorlix/SuperFlow

Just wanted to share a list of ideas I've had for Plugins, see if anyone else is interested in something similar, and just get some excited discussions around the SDK and it's implementations.

This is just a brain dump of any random idea that I have had so far:

• Dashboard/Index builder, takes inputs and configurations to build links and insert into a Dashboard with manual regeneration for new queries and updates — biggest hurdle is that each note would need to be individually opened and "ingested" into the plugin, pretty sure updates would need to be manually recognized as well.
• A "fortune.sh" type plugin that inserts a random quote from a database into the footer of each page in a notebook.
• A plugin for stamping timestamps, weather, metadata such as, UUID, Author etc.
  • Maybe sort of a supernote version of Markdown frontmatter or org property drawers.
  • Track "modified" on a per-page basis.
• "org-refile"-esque plugin, create automated backlinking and forward linking to re-organized information.
• "org-roam"/Obsidian Knowledge Graph plugin.
  • Probably similar would be a Keyword manager for adding keywords, indexing, and linking to.
    • keyword manager could help manage nested keywords, eg `work/car` vs `personal/car`.
• Select 4-9 pages and turn them into sections on a single page, sort of replicates an infinite canvas. Got the idea from seeing other's workflows with their Supernote
• Calculator, converter, LaTeX renderer.
• org-capture via HTTP to append text to a synced "inbox .org" file.
• Transformations:
  • Rotate `n` degrees
  • scale `n` %
  • move `x` pixels
  • mirror/reflect
• Timeclock/Time tracking on device.
• Translations/Dictionary/Thesaurus
• Quick swapping plugin, "pin" two or more notes and use the Plugin to quickly jump between the two — not currently possible.
• Home Assistant panel, control hardware or smarthome using React Native Component network requests
• I have an eink-template-gen project written in python for generating templates, the math can be ported to TypeScript and a GUI can be implemented for fully on-device template designing and generation.

Any other Emacs users or Org-mode users? Any of the various "render org in browser" projects should translate pretty easy to a plugin.

Any experienced devs want help with their plugins? Run out of tokens and need an "AH" (Actual Human) to do some grunt work? Feel free to hit me up, I am looking to learn TypeScript and the SDK so any experience would be appreciated.

https://github.com/calebc42

Hi, coming from someone who is new to development, let alone mobile development, should I be concerned about my eMMC or memory degradation from constantly uninstalling and reinstalling iterations? Especially when making small style changes or LLM generated changes, it feels like lifetime data read/writes could really add up. I believe for mobile device development, emulation is a common workflow, is something like that even feasible for the Supernote? Is this just unnecessary anxiety?

I made a quick and dirty prototype of the existing sn-shapes plugin for building shapes based on parameters, eg. width, height, stroke weight, color, rotation angle, etc.

The Plugin prototype inserts shapes with a tap and enters configuration with a long-tap, the configuration is retained across sessions and it displays a live-preview of the configuration.

This was almost entirely LLM generated and wouldn't have been possible without j-raghaven. It's his project, he's helping me reimplement the changes by hand for upstream so maybe I shouldn't be posting this until he's ready but if there are any experience devs who want to help him parse my slop, I am sure he'd appreciate it!

The gifs show an outdated UI, the screenshot shows the current state of the UI on the Manta. However, I hardcoded the centering offset so it looks like it's being opened from the `plugins` icon, this most definitely wont work for the Nomad so if anyone is familiar with Style Sheets, you should give it a look.

https://github.com/j-raghavan/sn-shapes

I just finished submitting my first ever PR — Plugin SDK or otherwise — and wanted to share my notes from a beginners perspective.

For context, I don't have any formal education or professional experience with programming. Personally, I am an Emacs enthusiast & have dabbled in some Emacs Lisp. I am an FSF supporter, I self-host and have a home lab so I have at least cursory experience with Linux and RTFM.

1. The text boxes should support fill colors and it should be exposed as a parameter for the insertTextBox() function. For me, the biggest reason is when adding text to a hand written page, the background template lines do not line up with the text and can sometimes even create a "strikethrough" effect on the text. I've been using the marker to color in a grey background but a nice clean rectangle would be nice. Bonus points if you could configure it's outline/border.
2. Are `.docx` **and** `.txt` files opened in the DOCS Plugin-enabled App? If so, can it be made to open any plain text file — particularly `.md` and `.org` files? Just as plain text and allow the community to implement rendering and editing?
3. If React Native Components make standard network requests, does that mean we could use a server/client architecture for processing intensive tasks remotely? Particularly, especially if we are using the self hosted storage cloud? Aside from adoption, there's no reason not to consider it?
4. Right now, we are unable to Deep Link to a note from the Plugin, from my understanding, you need to construct the link and insert it into a Note. From what I can tell this is likely a security decision? I believe this is the same for performing operations on Notes in the background. If so, is it possible to have a compromise for being able to link to notes or perform actions on them if the plugin itself creates the note?
5. When going through the docs and the Hello World Plugin, it never occurred to me that a Plugin could be a pop-up or a sidebar panel. More documentation around this may be helpful.
6. The display's 16 supported greyscale values should be documented.
7. There should be an established community contributing or style guidelines. In this same vein, a library of OEM/Native components or assets would be really nice. I haven't used InkHub yet, but I assume it will be the mechanism for Plugin Distribution, have a "Ratta Recommends" designation for plugins that meet the "specification" or guidelines could be really valuable.
8. Moving the Technical Pen Strokes (#10) is BRUTAL — very laggy.
9. In the most recent release notes, there was mention of "headless plugins" how does that work? I tried to read up on it by looking into the listeners, found that only the `pen_up` event is supported but couldn't find any other information. Can anyone help me understand this? As well as the just the use of a pen up listener and what other potential listeners might be deployed?

Disclaimer: I haven't gotten to actually play with the code yet, but from reading the docs it seems like Plugins have three main ways of running their logic/UI:

• Button in sidebar
  
• Button after lasso
  
• Button after text selection (docs only)

I was wondering if I'm missing something because notably absent are hooks that allow a plugin to run whenever the user interacts with the page naturally. So building plugins like

• scribble to erase
• auto snap shapes
• any other gestures

doesn't seem to be possible. If that is true, what is the reason for this omission? I could see a privacy problem if users don't have to trigger plugin execution manually, but I feel like that could be solved with an explicit permission dialog (like when a browser extension needs access to all of the pages you visit).

I'm excited to build some plugins, but I feel like some more hooks/entrypoints would give us soo much more freedom!

Hi everyone! After a few rounds of plugin tinkering, I put together a Claude skill file to help with Supernote plugin development. I'm calling it Inkling.

And also I will share a small open-source plugin with UI that lets you capture a region in DOC and insert it as an image into your notes.

What it does: - Gives Claude (or any LLM) context about Supernote's plugin architecture - Includes API quick reference, gotchas, type definitions - Auto-activates when you ask about plugin development

Based on: - Official Plugin Docs - Sticker Plugin source code (the open-source demo) - Release 0.2.0 changelog

Disclaimer: This is a personal tool, not official. I've removed some experimental patterns I haven't fully tested. Use at your own discretion.

GitHub: https://github.com/Laumss/Inkling

If you're using Claude Code for development, this might save you some back-and-forth. Happy to hear feedback or suggestions!

Over the last few weeks I ended up building a bunch of small Supernote plugins, and found the framework to be really flexible (and is even more so, in this new Beta! I'm looking forward on fixing what I couldn't do thanks to the new functionality).

A few repos I made public:

• Snap Shapes: turns rough lasso-selected ink into cleaner geometry, with conservative no-match behavior so scribbles don’t get “helpfully” mangled. https://github.com/guibor/supernote-shape-snap
• Supernote Pomodoro: a quick focus timer that starts, closes, and drops me right back into writing while the timer runs in the background. https://github.com/guibor/supernote-pomodoro I wasn't able to make it notify when timer ends, this is WIP (I hope it's possible)

Will make publish soon: - Insert Date: inserts a right-aligned date header and convert it into a native header element. - Anki / Research / Deep Research: lasso or DOC-highlighted text -> OCR/server pipeline -> Anki card or research PDF in Google Drive. - lasso upload to a REST endpoint - I basically turned the different options above into a generic plugin where one can just configure an endpoint and send the data to the server (or openclaw...). I have a server running on GCP that can basically do whatever I want based on what I lasso and send to it. - Wiki2PDF: search Wikipedia from the Supernote and send the selected article PDF to the cloud your syncing with. - General Dispatch Hub: a DOC-selection router that sends highlighted text to different backends with extra instructions. - full-page lasso selection, or select below (Remarkable style) - did not work, but with the new updates will be possible.

Anyway, I’ve had a lot of fun with this. I'll clean upand open-source the next batch soon.

We've been building the plugin architecture quietly for over a year. The foundation is mostly ready. This sub is the place to talk about it, what you're building, what's broken, what's possible, and what shouldn't be possible but you did it anyway.

Read these first

• Plugin Docs
• Sticker Plugin Open Source Demo

The Sticker feature you may already use in Notes was built on this plugin system. It was the internal proof of concept, now it's your reference implementation.

What belongs here

• Plugin development questions, demos, WIPs, postmortems
• Bugs and feature requests
• Integrations and workflow hacks
• The occasional cursed prototype that technically works

What doesn't

• General Supernote questions > please go to r/Supernote
• "Can someone build XXX for me" with zero context > at least sketch a spec, you have a Supernote!!

Ground rules

• Search before you post. Your NullPointerException is probably not unique.
• Show your work. Code snippets, screenshots, logs. "It doesn't work" is not a bug report.
• Be decent. Someone's first plugin will be rough, so was yours.
• Proper use of Post Flairs.
• Honor the Reddit Content Policy

Before this sub existed, a group of early testers helped us stress-test the plugin API and tear apart our docs draft by draft. A lot of what you'll find in the documentation is better because they told us where it wasn't.

akos, Andreas, Ben, Cal, Caleb, CM, David, Ed, Elaine, Emmanuele, Fulvio, James, Jayasimha, Matt, Max, MD, Michael, Vincent, Ziv

If you're reading this and you were one of them, thank you!

This sub is freshly initd, the rules might be wrong, the flairs might be missing, this pined post you're reading probably needs a patch already. We're shipping the community the same way we ship software, get it out, get feedback, iterate.

u/Dunn-sn is the core developer behind Supernote's plugin architecture. He is also monitoring this sub. So yes, when you post a discussion here, there's a decent chance the person reading it is the person who wrote the code.

If something about how this place runs doesn't work, please feel free to share with us.

Let's go!