Axure RP Keyboard Shortcuts
Axure RP targets a genuinely different job than most wireframing tools — it's built for prototypes that need real conditional logic (if this field is filled, show that panel; if a variable equals X, navigate here), which is closer to lightweight programming than the click-here-go-there prototyping most design tools offer, and the shortcut set has grown correspondingly denser to support that extra logic layer. The Interactions panel shortcut is central because building meaningful logic in Axure happens almost entirely there, defining cases, conditions, and actions for a widget rather than relying purely on simple click-to-navigate links the way Figma prototyping mostly works. Dynamic Panels — Axure's mechanism for showing different content states based on logic or interaction — have their own dedicated creation and state-switching shortcuts, since managing multiple named states within a single panel is a uniquely Axure-flavored concept without a clean equivalent in most competing tools, which tend to model state changes as entirely separate frames or artboards instead. The people who reach for Axure specifically tend to be business analysts and senior UX practitioners on enterprise product teams who need to prove out a genuinely conditional workflow — a loan application that branches based on income bracket, a checkout flow that behaves differently for logged-in versus guest users — before a single line of production code gets written, since a stakeholder can click through the actual branching logic rather than just imagining it from a static flowchart. Annotations attached directly to widgets deserve mention too, since a big part of Axure's role on enterprise teams is producing something developers can build from directly, and written specification notes tied to specific widgets bridge the gap between a clickable prototype and a formal requirements document without needing an entirely separate spec file maintained in parallel.
Widget Placement
| Action | Windows | Mac | Description |
|---|---|---|---|
| Selection tool | Ctrl+0 (varies) or Esc | Cmd+0 | Returns to the default selection/pointer tool after using a drawing or widget-placement tool, standard convention for exiting a specialized tool mode. |
| Duplicate selected widget | Ctrl+D | Cmd+D | Duplicates the selected widget with a slight offset, standard convention shared across most design and wireframing tools. |
| Group selected widgets | Ctrl+G | Cmd+G | Groups the selected widgets into a single unit for moving, resizing, or attaching a shared interaction. Because Axure treats groups as a distinct object type from its Dynamic Panels, a grouped set of widgets can still have individual interactions on member widgets fire independently, unlike a Dynamic Panel where swapping states typically governs the visibility of everything inside it together. |
| Align selected widgets (left) | Ctrl+Alt+L (varies) | Cmd+Option+L | Aligns the left edges of multiple selected widgets to match, useful for cleaning up form fields or list items that were placed slightly out of line by hand. |
| Send widget to back | Ctrl+Shift+[ (varies) | — | Sends the selected widget to the bottom of the current page's stacking order, useful when a background shape or container needs to sit visually behind widgets placed on top of it. |
| Add annotation/notes to a widget | Notes panel (no keyboard shortcut) | — | Attaches written specification notes to a specific widget, commonly used to document expected behavior or edge cases for developers who'll eventually build the real thing from the prototype. |
Interactions Logic
| Action | Windows | Mac | Description |
|---|---|---|---|
| Open Interactions panel for widget | Double-click widget's interaction area, or Interactions tab | — | Opens the panel for defining conditional cases, triggers, and actions on the selected widget — the central place where Axure's genuine logic-driven prototyping actually happens, distinguishing it from simpler click-to-navigate prototyping tools. |
| Add interaction case | Interactions panel > Add Case | — | Adds a new conditional case to a widget's interaction, letting different logic branches trigger depending on variable values or other conditions, core to building genuinely dynamic prototype behavior. |
| Set global variable value | Interactions panel > Add Action > Set Variable Value | — | Adds an action that changes a global variable's stored value when a case fires, the mechanism that lets a prototype remember state across pages — for example, tracking whether a user answered a previous form question a certain way. |
| Preview prototype in browser | F5 | F5 | Launches the current prototype in a browser preview so you can click through the actual conditional logic and dynamic panel states live, rather than just inspecting the underlying case definitions in the editor. |
| Add condition to interaction case | Interactions panel > Case > Add Condition | — | Adds a conditional check (like 'if variable X equals value Y') to a case, determining whether that case's actions fire at all, the mechanism that makes Axure's logic genuinely branching rather than a simple linear sequence of actions. |
| Generate/publish prototype | Ctrl+F9 (varies) or Publish menu | Cmd+F9 | Generates a shareable, hosted version of the prototype (via Axure Cloud or a local HTML export) for stakeholders to click through without needing Axure RP installed themselves. |
Dynamic Panels
| Action | Windows | Mac | Description |
|---|---|---|---|
| Convert selection to Dynamic Panel | Right-click > Convert to Dynamic Panel | — | Converts the selected widget(s) into a Dynamic Panel, a container that can hold multiple distinct states shown conditionally, a uniquely Axure-flavored concept without a direct equivalent in most simpler prototyping tools. |
| Switch Dynamic Panel state (editing) | State dropdown in panel editor (no dedicated key) | — | Switches which named state of a Dynamic Panel you're currently editing, letting you build out different visual states (like a form's default versus error state) within the same panel container. |
| Add new state to Dynamic Panel | Panel state manager > Add State | — | Adds another named state to an existing Dynamic Panel, expanding how many distinct content variations that single container can switch between at runtime based on interaction logic. |
| Preview a specific Dynamic Panel state | Panel state manager > click eye icon | — | Temporarily previews how a specific named state of a Dynamic Panel looks without needing to run the full prototype, useful while designing several states of the same panel and wanting to check one visually without repeatedly triggering the interaction that would normally switch to it. |
Frequently Asked Questions
How is Axure's prototyping different from Figma's built-in prototyping mode?
Figma's prototyping is primarily click-to-navigate between static frames, suitable for demonstrating simple flows visually. Axure supports genuine conditional logic — variables, if/then cases, and calculations — letting prototypes behave more like a real functioning application with branching behavior based on user input, which is considerably more powerful but also requires more setup effort for simple flows.
What exactly is a Dynamic Panel, and why doesn't Figma have a direct equivalent?
A Dynamic Panel is a container that can hold multiple named states (different visual content) shown conditionally based on logic or user interaction, functioning like a mini state-machine within a single object. Figma's more frame-based prototyping model instead typically represents different states as entirely separate frames connected by prototype links, a different underlying structure for achieving a related outcome.
Is Axure RP considered harder to learn than Figma or Sketch for prototyping?
Generally yes, for teams specifically wanting the logic-driven prototyping capabilities — the added power of variables, conditions, and Dynamic Panels comes with a steeper learning curve than tools built primarily for visual design and simple click-through prototyping, which is why Axure tends to be adopted more by UX teams whose prototypes need to demonstrate genuinely complex, realistic interactive behavior.
Do global variables persist only within a single page, or across the whole prototype?
Global variables persist across the entire prototype session, not just a single page, which is precisely what makes multi-step conditional flows possible — a variable set on page one based on a user's answer can still be checked and branched on ten pages later, behaving more like application state than page-scoped content.
Can non-technical stakeholders actually understand an Axure prototype's logic without reading the case definitions?
Generally yes for the experience of clicking through it — a well-built Axure prototype behaves like the real product from the outside, branching and reacting exactly as the finished software would, even though the underlying if/then case configuration is only visible to whoever opens the editor, which is exactly the point of building the logic in the first place.
What is the difference between a Case and a Condition in Axure's interaction model?
A Case is a complete rule bundling together a condition and the actions that should happen when that condition is met, while a Condition is specifically the logical check within a case (like a variable equaling a certain value) that determines whether that case's actions actually fire — a single widget interaction can have several cases, each with its own condition, evaluated in order until one matches.