SkillAgentSearch skills...

scenario-blender-grease-pencil

Use when drawing or animating with Grease Pencil in Blender 5.x from Python: 2D or 2.5D illustration, frame-by-frame animation, a cutout or part-based 2D character, strokes with pressure, filled shapes with holes, in-betweens and interpolation, onion skin, Line Art outlines, strokes on 3D meshes, NP…

Install / Use

npx skills add scenario-labs/skills --skill scenario-blender-grease-pencil

Installs into whichever agent you are using.

About this skill
📄

SKILL.md

Installable skill definition

Quality Score

89/100

Supported Platforms

Universal

Our assessment of scenario-blender-grease-pencil

scenario-blender-grease-pencil scores 89/100 on our quality scale, 1613th of 4,705 Development & Engineering skills we index (top 35%).

Its SKILL.md is 18 KB long, well organised into 9 sections with 1 code example: a thorough specification that gives an agent plenty to work with.

With 1,048 GitHub stars, it is one of the more widely adopted skills in the catalogue.

Substance
30/30
Structure
17/20
Description
15/15
Adoption
13/20
Freshness
15/15

Maintenance, license and trust

  • The repository was last updated 35 days ago, so scenario-blender-grease-pencil is actively maintained.
  • Our last check on 2026-11-22 found the source still online.
  • It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
  • Its trust signals score 100/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands.

Automated pattern scan on 2026-11-20. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.

scenario-blender-grease-pencil compared with similar skills

All 4 of these similar skills score higher than scenario-blender-grease-pencil; compare them before choosing.

SkillScoreStarsUpdatedFormat
scenario-blender-grease-pencil (this skill)by scenario-labs891.0k35d agoSKILL.md
taste-skillby Leonxlnx100120.0ktodayCLAUDE.md
Agent-Reachby Panniantong100114.0ktodayCLAUDE.md
hyperframesby heygen-com10088.2ktodayCLAUDE.md
headroomby headroomlabs-ai10080.5ktodayCLAUDE.md

Frequently asked questions

How do I install scenario-blender-grease-pencil?
Run npx skills add scenario-labs/skills --skill scenario-blender-grease-pencil. The install tabs above show the steps for each supported agent.
Which AI agents does scenario-blender-grease-pencil work with?
It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
Is scenario-blender-grease-pencil safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. It is MIT-licensed and scores 100/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is scenario-blender-grease-pencil still maintained?
The repository was last updated 35 days ago, so scenario-blender-grease-pencil is actively maintained.

name: scenario-blender-grease-pencil description: "Use when drawing or animating with Grease Pencil in Blender 5.x from Python: 2D or 2.5D illustration, frame-by-frame animation, a cutout or part-based 2D character, strokes with pressure, filled shapes with holes, in-betweens and interpolation, onion skin, Line Art outlines, strokes on 3D meshes, NPR or hybrid motion graphics. Also when GP code fails (GPENCIL, frame.strokes, grease_pencil_modifiers), fills do not show, colors render dark, or draw brushes will not run from a script." license: MIT

Grease Pencil (v3, Blender 5.2)

Expert Grease Pencil work keeps every drawing editable and redrawable, puts meaning in the structure (which object, which layer, which key) and judges the result in motion. The agent draws through the data API (drawings are curves with attributes), builds characters the way 2D studios rig them, and reviews rendered frames instead of a viewport it cannot flip. If a sibling skill named here is missing from your available skills, load it with skill_get (Scenario MCP) or ask the user to install it (https://github.com/scenario-labs/skills#install); unattended, proceed from tool schemas and flag the gap.

REQUIRED BACKGROUND: scenario-blender-expert (execution channel, review loop, 5.2 API changes). Shot planning, boards and animatics: scenario-blender-previs-storyboard. Mesh animation principles: scenario-blender-animation.

Toolkit: scripts/bx_gp.py (tested on 5.2.1). import sys; sys.path.append("<this skill>/scripts"); import bx_gp as G.

Stance (the expert delta)

  • Tom Viguier (Andarta, Ewilan's Quest): the rig must never block redrawing. One GP object per physical element (about 60 for a lead character), parented, mostly FK by object transforms; layers inside each element by graphic logic (line above color); sculpting as the deformer; no armature weight painting on drawings, because every redraw would need new weights.
  • Tom: interpolate only "sculpted" pairs. Two keys interpolate cleanly only with the same number, order and color of strokes and the same points. Otherwise redraw, or "clip" to the nearest drawing instead of accepting distortion. Native interpolation ignores object animation: key transforms separately.
  • Falk David (GP module lead): fill is geometry, not material. A stroke fills when fill_id != 0; strokes sharing an id fill together with even-odd holes; hide_stroke hides the outline. Material fill toggles are deprecated and holdout "eraser fills" (Grant Abbitt's 4.4 method) are obsolete.
  • Grant Abbitt: the layer stack carries meaning and materials are paint buckets. Lines on top, a shadow layer (Multiply, lowered opacity, masked by the fills) in between, fills at the bottom. Editing a material recolors every stroke using it. Lock what you are not editing: erasers and sculpt act on all unlocked layers.
  • Elijah Sheffield: predictable color first. Standard view transform, flat unlit shading, white world. Verified trap: new layers have use_lights=True, and lit layers take their ambient from World.color (default 0.05), not from the world node tree, so a flat palette renders at about a quarter of its value.
  • Tom: multiplane discipline and layout first. Every 2D element parallel to the camera, a camera that never changes axis, 3D only where it saves time; camera, cuts and parallax are settled in layout, not discovered in compositing. Between objects, depth decides who draws on top.
  • Michael Weigl: motion reveals the surface. A painterly still breaks once it moves; judge 2.5D as a sequence. Sort groups of strokes (mesh islands), never individual strokes, and bake procedural output back to editable strokes.
  • Pablo Fournier (Blender Studio): design the shadows. Replace blobby 3D shading with blocky, drawn light and shadow shapes (a light and a shadow material per part). Fills are flat: use many small fills on curved surfaces, not one big fill pushed forward.

Establish first

| Input | Changes | Default when silent | | -------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- | | Deliverable | still, frame-by-frame shot, cutout rig, hybrid motion graphics, 2.5D over 3D | frame-by-frame shot | | Format | resolution, fps, length | 1920 x 1080, 24 fps keyed on twos [added]; social motion graphics: 1080 x 1920, 12 fps, 60 frames (Elijah) | | Look | flat or lit, line system | flat (unlit layers, Standard); ink line with pressure taper | | Line system | PEN constant width (matches Line Art, Elijah) or INK_PEN pressure on radius (cartoony, Grant) or PENCIL (pressure on radius and opacity) | INK_PEN | | Palette | material colors | hex sRGB values, one material per paint bucket | | Camera | ortho multiplane or perspective | ortho, front view, drawing plane XZ | | Who edits next | how much stays procedural | a human animator: everything bakes to editable strokes |

Workflow

  1. Stage and layout. cam = G.scene_2d(res, fps, frame_range, ortho_scale) (ortho camera at -Y, Standard, background). Plan the multiplane: which elements are separate objects and their depth order. Compute px = G.px_size(); line width in pixels is 2 * radius / px. GATE: a test render shows the frame; planned line widths are at least 1.5 px [added].
  2. Structure. G.new_object(name, layers=("Fills", "Shadow", "Lines")) per element (bottom to top, unlit), parent parts, place origins at joints. G.material(ob, name, stroke=hex, fill=hex) once per bucket. GATE: [l.name for l in ob.data.layers] matches intent; G.draw_order(objs) lists front to back as designed.
  3. Draw. Keys first: d = G.key(ob, "Lines", frame). Lines: G.add_stroke(d, G.smooth_path(control_pts), radius, pressure=G.taper(n), brush="INK_PEN", material=i); overlap then trim rather than landing ends exactly (Grant). Fills: G.add_shape(d, outline, holes=[...], material=i) on the Fills layer, outline on Lines. Bulk: G.add_strokes(d, specs) (3000 strokes in 0.04 s). Fix shapes with G.grab, G.dissolve, G.edit_op(ob, "stroke_smooth", ...). GATE: G.verdict(G.report(ob)) is clean and a full-resolution G.render_frame shows no gaps, leaks or overhangs.
  4. Color and shadow. Shadow layer: blend_mode='MULTIPLY', opacity lowered, use_masks=True, mask_layers.add(fills); paint the shadow shape past the edge and let the mask clip it; design it blocky (Pablo). Lit look: use_lights=True plus World.color as ambient plus lamps (verified: a sun only scales value on a flat drawing, a point light gives a gradient). GATE: sampled pixels match the palette under Standard.
  5. Animate. Replacement key G.key(..., mode="blank"), additive mode="copy", hold or cycle mode="instance" / G.cycle(...), end an exposure with G.end_exposure. Every visible layer needs a key at or before frame_start (Elijah). Cutout motion: key object transforms (FK). In-betweens: check G.match(dA, dB), then G.interpolate(ob, layer, frame, step=2, type, easing) (native, segment around frame) or G.inbetween(ob, layer, a, b, frames, spacing=[...] or ease=...) for the animator's own spacing, clip=True when the pair is different. GATE: G.exposures(ob, layer) per layer, G.render_strip(path, frames) read left to right for timing and pops, G.onion(path, frame, before, after) for arcs and spacing.
  6. 2.5D (optional). Outlines: G.lineart(source, radius=width_m) (the modifier radius is the line width). Strokes on meshes: G.project_to_surface(pts, mesh) and discard strokes with missed or occluder-captured points (Pablo's failure modes). Relight: G.relight(ob, canvas, light_dir, shadow, light). Procedural strokes: Geometry Nodes Curves to Grease Pencil with Instances as Layers off and a fill_id attribute, then apply to bake (procedures P7). Depth reorder without changing the image: G.push_depth(ob, delta). GATE: a moving render (strip or playblast) where the surface does not read as 3D (Weigl) and fills do not poke through (Pablo).
  7. Deliver. Render frames or video with the scene camera; keep the .blend editable (no applied procedural stage the animator still needs). GATE: every object's verdict clean, strip and final frames looked at, list what was not verified.

Numbers

| Value | Meaning | Source | | -------------------------------------------------------------------- | --------------------------------------------------- | ------------------------- | | radius = half line width (m) | width px = 2 x radius / px_size | verified | | px_size = ortho_scale / max(res_x, res_y) | ortho; perspective uses depth x 2 tan(fov/2) / res | verified | | 0.01 m | point radius while the radius attribute is absent | verified | | Line Art radius default 0.0025 m | is the line WIDTH: points get radius/2 | verified | | Elijah's Line Art thickness 60 (4.x) | about 0.006 m width in 5.2 | [inferred] | | use_lights True, World.color 0.05 | new layers render flat colors at about 25 % value | verified | | set_uniform_thickness(thickness=t) | sets radius t/2 | verified | | ~60 parts, ~100 rig versions, 2 weeks rig for a lead | Ewilan's Quest cutout scale | Tom | | 12 fps, 60 frames, ortho scale 8, Subdivision 2 to 3 on shape meshes | hybrid motion graphics | Elijah | | Stabilizer 40 px / 0.9 bundled, Elijah uses ~60 on demand | only for long curves | Elijah, verified defaults | | 1 light bounce | enough for stylized relighting | Weigl | | GP anti-aliasing aa_samples 8 | scene

Truncated for display — read the full file on GitHub.

Related Skills

View on GitHub
GitHub Stars1.0k
CategoryDevelopment
Updated1mo ago
Forks129

Languages

Python

Trust signals

100/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

No cautions