makepad-2.0-events

Overview of makepad-2.0-events skill

What makepad-2.0-events does

The makepad-2.0-events skill is for working with Makepad 2.0 event and action handling without guessing at callback shape, state flow, or render timing. It is most useful when you need to connect UI interactions in Splash to Rust-side logic, or when you are debugging why an event does not fire, does not propagate, or does not update the view.

Who should use it

Use the makepad-2.0-events skill if you are building or maintaining Makepad frontend UI, especially component-driven apps that rely on on_click, on_render, on_return, on_startup, MatchEvent, or script_eval!. It is a strong fit for Frontend Development work where the hard part is not syntax alone, but deciding whether logic belongs in Splash, Rust, or the bridge between them.

Why it is different

This skill is centered on Makepad’s two-layer model: inline Splash handlers for local UI behavior, and Rust event matching for broader app logic, async work, and external state. That separation is the main adoption decision point. If you only need a generic prompt to “handle events,” you will likely miss Makepad-specific rules; this skill helps you choose the right layer and wire it correctly.

How to Use makepad-2.0-events skill

Install and first read path

Install the makepad-2.0-events skill with the directory’s normal skill command, then open SKILL.md first and references/event-patterns.md second. For this repo, those two files give the fastest path to usable makepad-2.0-events usage because the reference file contains working patterns you can adapt instead of rewriting event code from scratch.

Turn a rough goal into a usable prompt

For best results, describe three things: the widget or event source, the state change you expect, and where the update should happen. A weak request is “make the button work.” A stronger prompt is “Use makepad-2.0-events to wire a Button click in Splash to update state.counter, then refresh the label through script_eval! and .render().” That gives the skill enough structure to choose between inline handlers, Rust matching, and runtime patching.

What to inspect in the repo

Start with references/event-patterns.md for complete flows such as button click, startup render, and state-driven UI refresh. Then inspect the event sections in SKILL.md for handler names, bridge macros, and scope boundaries. If you are adapting the pattern to your own app, search for the nearest existing event path before inventing a new one.

Practical usage tips

Prefer the smallest complete event chain: source event, handler, state mutation, re-render. In Makepad 2.0, adoption problems usually come from putting logic in the wrong layer or forgetting the render step after state changes. When using the makepad-2.0-events skill for Frontend Development, keep your prompt explicit about whether the response should stay in Splash, move into Rust, or cross the bridge with script_eval! or script_apply_eval!.

makepad-2.0-events skill FAQ

Is this only for Makepad 2.0 UI events?

Yes. The makepad-2.0-events skill is specifically about Makepad 2.0 event and action handling, not generic frontend event systems. If you are using React, Vue, or another framework, the patterns may be conceptually useful but the code will not transfer directly.

Do I need to know Makepad before using it?

Basic Makepad familiarity helps, but the skill is still useful if you are learning the framework and need an installable guide to event flow. It is especially helpful when you already know what you want the UI to do but are unsure whether to write on_click, MatchEvent, or a bridge macro.

When should I not use this skill?

Do not reach for makepad-2.0-events if your task is mostly layout, styling, or unrelated app architecture. Also skip it if your problem is not event-driven, because the skill is optimized for interaction handling, callback behavior, and state updates.

How is it better than a generic prompt?

A generic prompt may explain events abstractly, but the makepad-2.0-events skill is tuned to Makepad’s actual control flow, naming, and code shape. That matters when you need a working event path, not just a conceptual answer.

How to Improve makepad-2.0-events skill

Give the full interaction path

The best makepad-2.0-events usage comes from specifying the event source, expected output, and state owner. For example: “When TextInput changes, update state.query in Splash, debounce only in Rust, and re-render the filtered list.” This is stronger than saying “handle input change” because it tells the skill where the logic belongs and what behavior counts as success.

Include the failure mode you are seeing

If you are debugging, name the symptom: callback not firing, state changing but UI not updating, or action reaching Rust but not affecting the widget tree. Those details help the makepad-2.0-events skill distinguish between handler wiring, bridge usage, and render timing issues.

Iterate from a working pattern

Use the reference examples as a base, then change one variable at a time: widget type, event type, or state update path. That reduces guesswork and makes it easier to spot whether your issue is syntax, scope, or lifecycle. For makepad-2.0-events, this is usually the fastest way to improve output quality.

Ask for the layer you actually need

If you only need local UI behavior, ask for a Splash-only solution. If you need business logic, async work, or external integration, ask for the Rust-side MatchEvent flow. Clear layer selection is the biggest quality lever for this skill, and it prevents overcomplicated answers that mix concerns unnecessarily.