Nemo

Open-source motion design and 2D animation, in one app. A full keyframe motion editor — editable easing curves, parenting, 3D layers, mograph, rigging, GPU effects — sharing the same document as a frame-by-frame vector drawing tool with automatic inbetweening. On the desktop or in your browser.

---

Why Nemo exists

Frame-by-frame animation is well served by open source — Krita, OpenToonz and Blender's Grease Pencil are all genuinely good tools. Motion design is not. If you need to keyframe, ease, parent, rig and composite the way a motion designer actually works, the free and open options are unmaintained, narrow single-purpose exporters, or built for a different job entirely. So the professional standard stays proprietary and subscription-only, and everyone who can't justify a subscription — students, small studios, anyone in a place where it simply isn't an option — is shut out of the craft.

Nemo exists to close that gap: motion tooling that doesn't apologise for being free, living in the same document as a real drawing tool, under a license that guarantees it stays that way.

Status: early alpha

Nemo is usable and under daily development, but it is not stable yet. Expect bugs, rough edges, and occasional breaking changes to the file format. Please don't put an important production on it without keeping backups.

If you try it, bug reports and ideas are genuinely the most useful thing you can send — there's also a Comment button inside the app that files an issue for you, screenshot attached. There's also a Discord if you'd rather chat, show off what you made, or just hang around.

Try it

In the browser — no install, requires a WebGPU-capable browser (recent Chrome, Edge, or Safari 26+):

https://nemomotion.org

On the desktop — build from source (see Building below). Packaged releases are not published yet.

What's in it today

Nemo is built around two connected modules. They're not separate editors — they're two views of the same document.

Animation 2D — drawing and inbetweening

• Vector brush with pressure support, stabilizer, and customizable tips
• Eraser, fill (with linked-fill regeneration), shape and boolean tools
• Automatic inbetweening — set two keyframes, Nemo generates the frames between, with feature-aware stroke matching rather than naive point interpolation
• Onion skinning, light table, X-sheet, flip/roll playback
• Bitmap brush layer with seeded dab stamping (texture stays put across generated frames)
• Layers with blend modes, groups, and components
• Track mattes — alpha or luma, stackable, with a keyframable on/off period

Motion — keyframe animation

• Position / Anchor / Rotation / Scale / Opacity keyframes on any layer
• Editable easing curves per key pair, motion paths, and a graph editor
• Deform an imported image with an editable mesh, animatable per vertex
• On-canvas joystick and slider widgets to drive a rig (never rendered)
• Parenting, including weighted blending across several parents at once
• Expressions on any property, with a code editor that splits the canvas
• 3D layers with per-vertex projection, camera, and a transform gizmo
• Mograph duplicator (grid / radial / along-path, with stagger and per-property effectors)
• Rig tool — bones drawn with the pen, tangent-driven rotation, IK

Effects, import/export, and more

• GPU effects library (WGSL shaders) plus built-in blur, color, distort, and stylize effects
• Export to MP4, MOV, WebM, GIF, and JSON; PNG sequences; OCA export
• Import PSD files, ABR brushes, images, video, and audio
• Camera export as a .jsx script, Lottie preview
• Scripting API (nemo.*) with HTML panels and plugins
• Labs — ~35 experimental tools behind a panel (lipsync assistant, speed lines, screentone, French curve, predictive stroke, pose library, and more)
• Kitsu integration for production tracking (early, not yet verified against a real production Kitsu instance — treat as experimental for now)
• Interactive in-app tutorial, 25 modules, in English, French, Japanese, and Spanish

What's next

The goal is one application for the whole 2D production chain — so a project stops being a relay race between five programs that each own a piece of it and each disagree about what a frame, a layer or a timing actually is. Blender showed that a single app can hold a whole pipeline. 2D still has no open-source equivalent.

Today Animation 2D and Motion are the two parts that really exist, and that's deliberate: a tool that is solid on a narrow scope beats an ambitious suite that is fragile everywhere. StoryBoard is started, and marked in-dev in the UI.

Here is the rest of the map. None of it is promised, and the order will follow what beta feedback actually asks for.

Infinite canvas — pre-production

A free space for research: references, sketches, colour keys, design exploration, notes. Where a project lives before it has a timeline.

StoryBoard

Boards, sequencing and timing, feeding straight into the animation stage instead of being exported and re-imported.

Editing — node-based

Cutting animated assets and boards together. Deliberately a node graph rather than a classic track timeline: in an animation pipeline a shot is rarely a flat strip of video, it's a graph of sources, versions and dependencies. A graph describes that honestly, where stacked tracks force you to flatten it.

Compositing — node-based

The same reasoning, one stage later: layers, effects and render passes as a graph.

Sound design

Timing sound with the animation instead of against it — the stage most 2D pipelines postpone to another program, and then fight.

This needs more than one person

I won't build all of this alone, and I would rather say so plainly than present a roadmap as a schedule. Each of these is its own craft: an editor, a compositor and a sound stage are three different disciplines, not three more features.

So if one of them is your craft, that is exactly where you would matter most — and the earlier you show up, the more the design is still open to being shaped by someone who actually does that job. The scripting API and the plugin system exist partly for this: a whole area can be prototyped without touching the core first. See Contributing.

Building

npm install
npm run dev      # desktop build (Tauri) with hot reload
npm run serve    # browser-only preview, no Tauri

Changes to the Rust/wasm engine under geometry-wasm/ need a rebuild before they show up in either mode:

cd geometry-wasm && wasm-pack build --target web --out-dir ../src/wasm

Same for the image vectorizer (vectorize-wasm/, sharing its actual tracing logic with vectorize-core/ — see that crate's own doc comment) — loaded lazily, only the first time the "Vectorize Image" dialog opens, not on every app boot:

cd vectorize-wasm && wasm-pack build --target web --out-dir ../src/wasm-vectorize

Run the tests with npm test (Node) and cargo test (inside geometry-wasm/, vectorize-core/, or src-tauri/).

How it's built

Nemo is a hybrid: Paper.js holds the document model (the source of truth), and a stateless Rust/WebGPU renderer (geometry-wasm/, built on vello) does the drawing, bridged through src/js/engine-bridge.js. The desktop app is Tauri v2. There is no bundler — src/ is the site root as-is, plain <script> tags.

The split is deliberate: Rust for the parts that must not wobble (geometry, rendering), JavaScript for everything else (UI, tools, bridges) so that iteration stays fast.

On AI-assisted development

Most of this codebase was written with the help of an AI assistant, and that's not hidden or downplayed — it's the bet. It lowers the barrier to contributing, including for people who code with AI help rather than as seasoned Rust/JS engineers.

The guardrail is CLAUDE.md: a long, blunt engineering guide documenting the project's invariants and post-mortems of bugs that have already bitten this codebase more than once (the "new item type handled in one consumer but not the others" family, in particular). It was written to be read by an AI assistant, but every rule in it applies just as much to a human — read it before touching the scene/save pipeline, the render engine, or Motion.

Contributing

Every kind of contribution counts equally here:

• Feedback — file an issue, or use the Comment button inside the app
• Code — with or without AI assistance, both welcome. See CONTRIBUTING.md
• Plugins — the scripting API exists precisely as an extension surface
• Non-code help — issue triage, documentation, tutorials, translation (the app already ships in fr/en/ja/es)
• Money — entirely optional, see below

There's no CLA. By opening a PR you agree your contribution ships under the project's license. Active contributors get access to dev-only channels on Discord.

Privacy

Nemo doesn't collect data. No analytics, no telemetry, no tracking — none is built in, none is planned. Your projects stay on your machine (or in your browser's local storage, for the web build); nothing about what you draw or how you use the app is ever sent anywhere.

The app does make network requests, but only for things you explicitly trigger: checking for app updates and submitting feedback (both talk to GitHub), and Kitsu production sync if you configure it. Nothing runs in the background, and nothing you didn't ask for leaves your machine.

Support

Nemo is free, and it stays free. There is no paid tier, no pro edition, and no feature that distinguishes a donor from anyone else — that would sit badly with the GPL spirit the project chose deliberately.

If you want to help fund the work anyway: ko-fi.com/mysteropodes

License

GPL-3.0-or-later — the same license family as Blender, GIMP, Inkscape, and Krita. Forks and commercial use are allowed; any distributed modification stays open.

Third-party components and the reasoning behind how they're bundled (notably ffmpeg, rebuilt without GPL or patent-encumbered codecs) are documented in THIRD_PARTY_NOTICES.md.