⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

v2.0.0

gimp-plugin

codeatcode@codeatcode⭐ 30 stars· last commit 18d ago· 0 open issues

Use when developing GIMP 3.0+ plugins in Python 3 - procedure registration, image and layer operations, GEGL operations, PDB calls, dialogs and progress bars, file export, or batch processing plugins

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐⭐ 30 on GitHubGitHub ↗

Growing

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

OSS AI Skills Collection

License

A comprehensive collection of AI assistant skills (SKILL.md files) following the skillreg.dev specification, designed to help to use and extend open-source projects (for plugins). Note: we test the majority of them and improving based on asking to the agents to extend the skills based on their experience.

What is this?

This repository provides reusable skill definitions that can be loaded into AI coding assistants. Each skill encapsulates domain knowledge, best practices, and workflows for specific tasks in open-source development.

Available Skills

Extend

SkillDescriptionLinesTags
Firefox ExtensionUse when developing Firefox WebExtensions - Manifest V2/V3 configuration, WebExtension APIs, content security policy, web-ext CLI, cross-browser support with the polyfill, AMO submission, or debugging extensions945firefox, webextension, browser-extension, mozilla, amo, manifest-v3
GIMP PluginUse when developing GIMP 3.0+ plugins in Python 3 - procedure registration, image and layer operations, GEGL operations, PDB calls, dialogs and progress bars, file export, or batch processing plugins1,024python, gimp, image-processing, graphics, plugin, gegl
Kate PluginUse when developing C++ plugins for Kate - KTextEditor Framework, CMake/ECM, Qt threading, KDE plugin architecture730kate, kde, text-editor, plugin, c++, qt, kde-frameworks
KDE PlasmoidUse when building KDE Plasma 6 widgets with a Python backend - plasmoid structure, metadata.json, QML UI, configuration system, plasmapkg2 packaging, KDE Store submission, or plasmoid testing and debugging1,085kde, plasma, plasmoid, widget, qml, qt, desktop
mGBA ScriptingUse when scripting mGBA emulator automation in Lua - console API, ROM and save state operations, frame callbacks, input handling, memory reading for cheats and RAM watches, sockets, or TAS and speedrunner tooling975lua, emulator, gba, gameboy-advance, scripting, memory-hacking
OpenCode PluginUse when developing plugins, tools, and extensions for OpenCode v1 - plugin contract, crash-prevention rules, ctx/event APIs, subagent lifecycle (abort races, compaction, orphan detection), MCP integration, testing patterns, or publishing to npm1,595opencode, plugin, ai-agent, mcp, tool-development
OpenRCT2 PluginUse when developing OpenRCT2 plugins in TypeScript - plugin registration and game actions, window and widget UI, event hooks, park, map, ride and entity access, network API, storage, or ES5 runtime constraints1,066openrct2, plugin, javascript, typescript, game-modding, rollercoaster-tycoon
Playwright Visual RegressionUse when setting up visual regression testing with Playwright - toHaveScreenshot baselines, masking dynamic content, handling animations, full-page and element screenshots, cross-browser runs, CI integration, VUDA MCP tooling, or debugging flaky visual diffs1,069playwright, visual-regression, screenshot, testing, e2e, vuda, vrt
Thunderbird ExtensionUse when developing Thunderbird MailExtensions - Manifest V2/V3 configuration, messenger.* APIs for accounts, messages, folders and compose, UI actions, message display scripts, Experiment APIs, ATN submission, or migration from legacy extensions813thunderbird, mailextension, email-extension, mozilla, atn, messenger-api

Frameworks

SkillDescriptionLinesTags
aiohttpUse when building Python async HTTP services or clients with aiohttp - web server routing, middleware, WebSocket, SSE, streaming, client sessions, pytest-aiohttp testing, or troubleshooting SSL and timeout issues1,300python, http, async, server, websocket, sse
BPCore EngineUse when building GBA games with the BPCore Lua engine - entity, sprite and tilemap functions, SRAM save and load, link cable multiplayer protocol, camera and scrolling, or optimization patterns914lua, gba, game-engine, gameboy-advance
CeleryUse when running background tasks with Celery - worker and broker configuration (Redis, RabbitMQ, SQS), task definitions, chains and chords, Celery Beat periodic tasks, routing, retries, Flower monitoring, or testing tasks with pytest1,339python, task-queue, async, distributed, celery
DjangoUse when building Django applications - security hardening, authentication and permissions, ORM optimization, PostgreSQL features, Django 6.0, migrations, testing, and ecosystem libraries2,599python, django, web-framework, async, hub
↳ django-adminUse when customizing Django Admin - save_formset, get_search_results, formsets, queryset optimization, db_index, custom URLs584python, django, admin, orm, optimization
↳ django-transactionUse when handling Django transactions and concurrency - atomic, select_for_update, on_commit, upserts, M2M ordering474python, django, transactions, concurrency, orm
Django BoltUse when building high-performance APIs with django-bolt - routing, JWT auth, msgspec serializers, WebSockets, SSE streaming, file uploads, ORM patterns, runbolt deployment, or migrating from DRF2,260python, django, bolt, api, rust, performance, async
Django CeleryUse when integrating Celery with Django - task definition and calling, django-celery-beat scheduling, worker deployment, Flower monitoring, testing tasks, batch processing, or choosing between cron and beat836python, django, celery, task-queue, periodic-tasks, django-celery-beat
Django HTMXUse when building dynamic Django web apps with htmx - partial rendering, HTMX responses, querystring tag, CSP888django, htmx, python, web, frontend, partial-rendering
Django NinjaUse when building Django REST APIs with django-ninja - Pydantic schemas, routers, CRUD endpoints, authentication, pagination, file uploads, async views, OpenAPI docs, or migrating from DRF2,013python, django, rest-api, pydantic, openapi, type-safe
Django StoragesUse when configuring django-storages for cloud file storage - STORAGES setting, Amazon S3, Google Cloud Storage and Azure backends, signed URLs, CDN and caching, multipart uploads, or storage testing1,093python, django, storage, s3, azure, gcs, cloud
Django TDDUse when testing Django applications with pytest - TDD workflow, pytest-django setup, factory_boy and model-bakery fixtures, DRF API testing, mocking and patching, integration tests, mutation testing with mutmut, or coverage1,087python, django, testing, pytest, tdd
Django UnfoldUse when theming the Django admin with django-unfold - settings and sidebar configuration, custom admin site, components and @display decorator, filters, actions, tabs, dark mode and styling, or Django 6.x compatibility883python, django, admin, unfold, theme, dashboard
django-allauthUse when implementing Django authentication - local accounts, OAuth, email verificat

// HOW IT'S BUILT

// FILES

2 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • extend/gimp-plugin/SKILL.md7.8 KBupstream ↗
    ---
    name: gimp-plugin
    description: Use when developing GIMP 3.0+ plugins in Python 3 - procedure registration, image and layer operations, GEGL operations, PDB calls, dialogs and progress bars, file export, or batch processing plugins
    metadata:
      author: mte90
      version: 2.0.0
      tags:
        - python
        - gimp
        - image-processing
        - graphics
        - plugin
        - gegl
    ---
    
    # GIMP Plugin Development
    
    Complete guide for developing GIMP 3.0+ plugins with Python 3.
    
    ## Overview
    
    GIMP (GNU Image Manipulation Program) supports plugins written in Python 3. GIMP 3.0 introduced significant API changes, GEGL-based image processing, and modern Python integration.
    
    **Key Features:**
    - Python 3 scripting (no longer Python 2)
    - GEGL (Generic Graphics Library) for image operations
    - New procedure registration system
    - GTK 3 dialog support
    - Access to all GIMP internal procedures
    
    ### GIMP 3.0+ Requirements
    
    ```bash
    # Check GIMP version
    gimp --version  # GIMP 3.0.0 or higher
    
    # Python 3 is bundled with GIMP
    # Plugins use the Python interpreter included with GIMP
    ```
    
    ### Plugin Locations
    
    ```
    # User plugins (preferred)
     ~/.config/GIMP/3.0/plug-ins/
    
    # System plugins
    /usr/lib/gimp/3.0/plug-ins/
    
    # Windows
    %APPDATA%\GIMP\3.0\plug-ins\
    
    # macOS
    ~/Library/Application Support/GIMP/3.0/plug-ins/
    ```
    
    ### Plugin File Structure
    
    ```
    my_plugin/
    ├── my_plugin.py           # Main plugin file (must be executable on Linux)
    └── __pycache__/           # Python cache (auto-generated)
    ```
    
    ```bash
    # Make plugin executable (Linux/macOS)
    chmod +x ~/.config/GIMP/3.0/plug-ins/my_plugin.py
    ```
    
    ## Basic Plugin Structure
    
    ### Minimal Plugin
    
    ```python
    #!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    
    import gi
    gi.require_version('Gimp', '3.0')
    from gi.repository import Gimp
    from gi.repository import GObject
    from gi.repository import GLib
    
    def my_plugin(procedure, run_mode, image, n_drawables, drawables, args, data):
        """Main plugin function."""
        Gimp.message("Hello from my plugin!")
        return procedure.new_return_values(Gimp.PDBStatusType.SUCCESS, GLib.Error())
    
    class MyPlugin(Gimp.PlugIn):
        ## Gimp.PlugIn virtual methods ##
        
        def do_query_procedures(self):
            """Return list of procedure names."""
            return ["plug-in-my-plugin"]
        
        def do_create_procedure(self, name):
            """Create procedure definition."""
            procedure = Gimp.ImageProcedure.new(
                self, name,
                Gimp.PDBProcType.PLUGIN,
                my_plugin, None
            )
            procedure.set_image_types("RGB*")
            procedure.set_documentation(
                "My Plugin Description",
                "Detailed help text",
                name
            )
            procedure.set_menu_label("My Plugin")
            procedure.add_menu_path("<Image>/Filters/Custom/")
            procedure.set_attribution("Author", "Author", "2024")
            
            return procedure
    
    Gimp.main(MyPlugin.__gtype__, sys.argv)
    ```
    
    ### Plugin with Parameters
    
    ```python
    #!/usr/bin/env python3
    
    import gi
    gi.require_version('Gimp', '3.0')
    gi.require_version('Gegl', '0.4')
    from gi.repository import Gimp, Gegl, GObject, GLib
    
    def my_filter(procedure, run_mode, image, n_drawables, drawables, args, data):
        """Apply filter with user parameters."""
        # Get parameters
        blur_amount = args.index(0)
        opacity = args.index(1)
        
        # Get active drawable (layer)
        drawable = drawables[0]
        
        # Apply GEGL operation
        Gimp.drawable_filter_new(drawable, "gegl:gaussian-blur")
        
        # Update image
        Gimp.displays_flush()
        
        return procedure.new_return_values(Gimp.PDBStatusType.SUCCESS, GLib.Error())
    
    class MyFilterPlugin(Gimp.PlugIn):
        def do_query_procedures(self):
            return ["plug-in-my-filter"]
        
        def do_create_procedure(self, name):
            procedure = Gimp.ImageProcedure.new(
                self, name,
                Gimp.PDBProcType.PLUGIN,
                my_filter, None
            )
            procedure.set_image_types("RGB*, GRAY*")
            procedure.set_documentation(
                "Apply custom blur filter",
                "Applies a configurable blur to the image",
                name
            )
            procedure.set_menu_label("My Blur Filter")
            procedure.add_menu_path("<Image>/Filters/Blur/")
            
            # Add parameters
            procedure.add_argument_from_property(
                GObject.Value(GObject.TYPE_DOUBLE),
                "blur-amount",
                "Blur Amount",
                "Radius of the blur",
                0.0, 100.0, 5.0
            )
            procedure.add_argument_from_property(
                GObject.Value(GObject.TYPE_DOUBLE),
                "opacity",
                "Opacity",
                "Filter opacity (0-100)",
                0.0, 100.0, 100.0
            )
            
            return procedure
    
    Gimp.main(MyFilterPlugin.__gtype__, sys.argv)
    ```
    
    ## Procedure Registration
    
    ### Procedure Types
    
    ```python
    # Image procedure (operates on image)
    procedure = Gimp.ImageProcedure.new(
        self, name,
        Gimp.PDBProcType.PLUGIN,
        callback, data
    )
    
    # Load procedure (file import)
    procedure = Gimp.LoadProcedure.new(
        self, name,
        Gimp.PDBProcType.PLUGIN,
        callback, data
    )
    
    # Save procedure (file export)
    procedure = Gimp.SaveProcedure.new(
        self, name,
        Gimp.PDBProcType.PLUGIN,
        callback, data
    )
    
    # Brush procedure (create brushes)
    procedure = Gimp.BrushProcedure.new(
        self, name,
        Gimp.PDBProcType.PLUGIN,
        callback, data
    )
    ```
    
    ### Menu Registration
    
    ```python
    procedure.add_menu_path("<Image>/Filters/MyFilters/")
    procedure.add_menu_path("<Image>/Edit/")           # Edit menu
    procedure.add_menu_path("<Image>/Select/")         # Select menu
    procedure.add_menu_path("<Image>/View/")           # View menu
    procedure.add_menu_path("<Image>/Image/")          # Image menu
    procedure.add_menu_path("<Image>/Layer/")          # Layer menu
    procedure.add_menu_path("<Image>/Colors/")         # Colors menu
    procedure.add_menu_path("<Image>/Tools/")          # Tools menu
    procedure.add_menu_path("<Filters>/")              # Filters menu
    procedure.add_menu_path("<Toolbox>/Xtns/")         # Extensions
    procedure.add_menu_path("<Image>/Filters/Custom/My Plugin")
    ```
    
    ### Image Types
    
    ```python
    procedure.set_image_types("RGB*")       # RGB images (any alpha)
    procedure.set_image_types("RGBA")       # RGB with alpha only
    procedure.set_image_types("RGB,GRAY")   # RGB or grayscale
    procedure.set_image_types("*")          # All image types
    procedure.set_image_types("INDEXED*")   # Indexed images
    ```
    
    ### Parameters
    
    ```python
    # Boolean
    procedure.add_argument(
        GObject.param_spec_boolean(
            "preview",
            "Preview",
            "Show preview",
            True,  # default
            GObject.ParamFlags.READWRITE
        )
    )
    
    # Integer
    procedure.add_argument(
        GObject.param_spec_int(
            "radius",
            "Radius",
            "Blur radius in pixels",
            1,    # min
            100,  # max
            5,    # default
            GObject.ParamFlags.READWRITE
        )
    )
    
    # Float/Double
    procedure.add_argument(
        GObject.param_spec_double(
            "amount",
            "Amount",
            "Effect amount (0-100)",
            0.0,   # min
            100.0, # max
            50.0,  # default
            GObject.ParamFlags.READWRITE
        )
    )
    
    # String
    procedure.add_argument(
        GObject.param_spec_string(
            "text",
            "Text",
            "Text to render",
            "",  # default
            GObject.ParamFlags.READWRITE
        )
    )
    
    # Enum
    from gi.repository import Gimp
    procedure.add_argument(
        Gimp.param_spec_enum(
            "blend-mode",
            "Blend Mode",
            "Layer blend mode",
            Gimp.LayerMode.__gtype__,
            Gimp.LayerMode.NORMAL,
            GObject.ParamFlags.READWRITE
        )
    )
    
    # Color
    procedure.add_argument(
        Gimp.param_spec_rgb(
            "color",
            "Color",
            "Foreground color",
            True,  # has alpha
            Gimp.RGBA(1.0, 0.0, 0.0, 1.0),  # default red
            GObject.ParamFlags.READWRITE
        )
    )
    ```
    
    ## Deep Dives
    
    For detailed reference material, load these files on demand:
    
    - **Image Operations, GEGL, and PDB** —
  • README.mdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/codeatcode-oss-ai-skills-extend-gimp-plugin.md

// REPO STATS

30 stars
0 open issues
Last commit: 18d ago