Tiny Tool Development

// Editor Tools / Available on Fab

Performance Preset Wizard

Reusable Unreal Editor performance profiles with reviewable scalability and CVar changes.

Creates, reviews, applies, and restores reusable performance presets.

Package scalability and CVar intent into named presets for editor work, QA, capture, runtime selection, and restore workflows.

Show on Fab Read GitHub documentation Back to catalogue
product slidesCommitted walkthrough media; documentation carries the detailed operating context.

// PRODUCT WALKTHROUGH

Visual orientation backed by the product facts below.

Use the gallery as quick orientation, then inspect mechanics, actions, outputs, integrations, and boundaries.

Overview Runtime target presets authored, reviewed, applied, and restored

Data-driven presets for packaged runtime targets.

// THE PAIN

Before the plugin enters the chat.

"Drop scalability for the demo" — and the project never quite returns.

PAIN

Someone types a few CVars for a capture session. QA applies a different scalability combo for testing. Monday's authoring machine still runs last week's leftovers.

Performance state lives in chat logs and muscle memory instead of named assets. Restoring 'normal' becomes guesswork — and nobody agrees what normal was.

What that feels like

  • Scalability and CVar tweaks scatter across people and sessions.
  • Capture, QA, and authoring each invent their own console recipe.
  • Rollback depends on remembering what changed — not on a stored preset.
// WHAT YOU GET

After — in the editor, not in a slide deck.

Preset assets that bundle scalability and CVars with review, apply, and restore.

GAIN

Performance Preset Wizard stores intent as reviewable preset assets — with backup history, apply paths for editor and runtime, and restore when the session is over.

  • Named presets shared between editor work, QA, and packaged test runs.
  • Optional CVar overrides with backup history before apply.
  • A runtime apply path instead of remembered console recipes.

// HOW IT WORKS

The product architecture, inspected from the plugin surface.

These are the moving parts I would place on the page so buyers can understand what they are actually getting beyond the slide narrative.

01 / Preset

Scalability and CVar choices become assets.

Preset assets store quality levels and optional console variable overrides as a named state the team can review.

02 / Apply

Editor and runtime paths can use the same intent.

The runtime subsystem, editor tooling, and runtime selector widget allow profiles to be applied where the workflow needs them.

03 / Restore

Backup history makes rollback concrete.

Before state changes, previous values can be captured so teams are not relying on memory to undo performance experiments.

// FIT

Who actually reaches for this.

Teams that repeatedly switch between authoring, profiling, review, capture, and low-cost editor states.

Turns scalability settings and CVar overrides into a traceable editor process.

// SURFACE

Where it lives in Unreal.

Preset authoring, scalability values, optional CVar overrides, restore flows, automation notes, sample presets, and CI references.

// CAPABILITY MAP

Feature groups with the value of each part made explicit.

Grouped from plugin modules, public APIs, automation hooks, and documented workflow surfaces.

Preset authoring

The plugin turns performance recipes into named project artifacts.

  • Create presets for authoring, QA, demo, capture, and low-cost modes.
  • Bundle scalability levels with optional CVar overrides.
  • Review what a preset will change before applying it.
  • Share presets as assets instead of chat instructions.

Apply and restore

Changing performance state is useful only when rollback is equally visible.

  • Apply a preset in editor workflow.
  • Use runtime subsystem paths where packaged tests need them.
  • Restore previous values from backup history.
  • Avoid permanent leftover CVars from temporary work.

Automation hooks

The exposed tools keep the workflow small and repeatable.

  • list_presets shows available profiles.
  • apply_preset switches to a named profile.
  • restore_previous returns from temporary state.
  • Preset assets preserve intent for review and CI references.

// OPERATOR TOOLS

Concrete actions, expected result, and mutation boundary.

This is the part that keeps product marketing honest: buyers can see which buttons, APIs, or MCP tools matter and what they change.

// ACTION

list_presets

Why it matters
Shows available performance profiles.
Operator result
Operators choose from named states instead of memory.
Change surface
Read-only.
// ACTION

apply_preset

Why it matters
Applies scalability and CVar choices from a preset.
Operator result
The editor or runtime moves to the selected profile.
Change surface
Changes scalability/CVar state.
// ACTION

restore_previous

Why it matters
Restores values captured before apply.
Operator result
Temporary test or demo state can be left cleanly.
Change surface
Changes scalability/CVar state.
// ACTION

Review preset asset

Why it matters
Inspects scalability and CVar intent before application.
Operator result
A profile can be discussed as a project artifact instead of a hidden console recipe.
Change surface
Read-only preset review.
// ACTION

Runtime selector widget

Why it matters
Lets packaged test flows apply known presets at runtime.
Operator result
QA and demo builds can switch states without recreating editor-only setup.
Change surface
Changes runtime scalability/CVar state when used.

// TYPICAL FLOW

From inspection to use without losing the product boundary.

01

Author a preset with clear scalability and optional CVar intent.

02

Review the expected changes before applying the profile.

03

Restore previous settings or use automation where the documentation supports it.

// PROOF AND BOUNDARIES

Signals that make the product specific, plus the limits worth saying out loud.

Each card turns implementation facts into buyer-facing proof without pretending the tool solves the wrong problem.

Modules Runtime subsystem plus editor module
Objects Preset assets and backup history
Controls list_presets, apply_preset, restore_previous
Surfaces Editor workflow and runtime selector widget
State model Scalability values plus optional CVar overrides
Rollback Previous values can be captured before a preset is applied
Use cases Authoring, QA, profiling, capture, demo, low-cost sessions

Outputs

What the plugin leaves behind when the workflow is doing useful work.

  • Preset assets

    Reusable named performance states.

  • Applied profile

    A deliberate scalability/CVar state for the current task.

  • Backup history

    Evidence needed to restore previous values.

  • Runtime-selected state

    A packaged test or demo build using an intentional preset.

  • Reviewable CVar list

    The exact console variables a preset plans to touch.

Inspection basis

The concrete code, API, and tool surfaces used to shape this product page.

  • Manifest

    Runtime and editor modules show the product crosses editor authoring and runtime selection.

  • Subsystem

    Runtime subsystem, preset assets, runtime selector widget, backup history, scalability, and CVar handling are present.

  • MCP tools

    list_presets, apply_preset, and restore_previous define the automation-facing core.

  • Workflow boundary

    The inspected surface is repeatable state switching and restoration, not automatic performance diagnosis.

Integrations

Where the product connects without losing ownership of its own domain.

  • QA and capture

    Repeatable profiles reduce manual setup differences.

  • Unreal Capability Mesh

    Preset actions can become routeable editor jobs.

  • Runtime UI

    A runtime selector widget supports packaged test flows.

  • Team presets

    Shared assets let leads standardize review, demo, and low-cost modes.

Safety model

The boundaries that make the tool understandable before automation enters.

  • Review before apply

    Preset intent is visible before state changes.

  • Backup history

    Rollback does not depend on memory.

  • Named profiles

    Temporary states become understandable project artifacts.

  • CVar explicitness

    Optional console variable overrides are part of the preset definition, not a hidden side effect.

Not for

The cases where the product promise would be the wrong expectation.

  • Teams expecting automatic performance diagnosis.

  • Projects where CVars and scalability must never be touched from tools.

  • Visual sign-off sessions where any temporary quality change would be unacceptable.

// PRODUCT MEDIA

Tutorial and platform embeds stay attached to product context.

YouTube, Discord, LinkedIn, and Fab widgets are reserved for product presentation, explanation, support context, or tutorials. No third-party widget loads automatically.

Tutorial video

YouTube

Product walkthroughs, setup explanations, and tutorial material.

Embed source pending. No third-party widget is loaded here.

Open platform
Primary support context

Discord

Discord-first product support, quick questions, setup discussion, and community context.

Embed source pending. No third-party widget is loaded here.

Open platform
Professional context

LinkedIn

Company background, provider identity, project credibility, and listing context.

Embed source pending. No third-party widget is loaded here.

Open platform
Marketplace context

Fab

Product listing context, license details, purchase route, and marketplace availability.

Embed source pending. No third-party widget is loaded here.

Open platform

// INFORMATION

All essential product signals in one place.

Status Available on Fab
Category Editor Tools
Unreal Engine 5.4; current descriptor/build line UE 5.8
Source state PerformancePresetWizard.uplugin VersionName 1.1.3 / Version 4
Primary surface Preset authoring, scalability values, optional CVar overrides, restore flows, automation notes, sample presets, and CI references.
Marketplace Fab listing available
Direct sales None on this website
Support route Discord first; product context lives on this page
Listing context Fab for marketplace, LinkedIn for public provider identity
Fact surface 3 functions / 3 settings / 3 failure modes / 1 bridge
Boundary Runtime/editor preset authoring and apply/restore tool for reusable Unreal scalability and CVar profiles.
Primary workflow Author or select a UPerformancePresetAsset, review its scalability and CVar effects, apply it manually, and restore the captured previous state when needed.

// NOTES

Practical boundaries.

The tool is designed around repeatable editor state changes and restoration.

Fab remains the purchase and marketplace detail surface.

// LEGAL / PRIVACY

Static information page.

Purchases, downloads, marketplace accounts, and platform-specific license details are handled outside this website. Product or tutorial widgets are loaded only after activation, where configured.

Provider details are listed in the legal notice. The current site template does not set first-party cookies and does not load analytics scripts.

Legal Notice Privacy Policy

// RESOURCES

Open the channel that matches the next question.

Fab listing

Listing, license, purchase, account, and download context are handled by Fab.

Open

GitHub documentation

Manuals, quickstarts, settings references, troubleshooting, technical notes, and release material live in GitHub.

Open

Discord support (primary)

Start quick questions, setup help, support context, and product-fit discussion on Discord.

Open

Plugin support email

Formal plugin support requests can be sent to the dedicated support mailbox.

Open

LinkedIn company context

Company background, public provider identity, and listing context are available on LinkedIn; support still starts on Discord.

Open

// RELATED

Nearby tools in the catalogue.

Editor Tools

Code Copyright Editor

Keeps copyright headers, project notices, metadata, and CI checks consistent.

View page
Editor Tools

Lightweight Editor Mode

Reduces Unreal Editor viewport and rendering cost through reversible profiles.

View page
Editor Tools

LogLevelEditor

Finds Unreal log categories and changes verbosity levels in a focused surface.

View page

// TOOL NAVIGATION

Continue through the catalogue.

Each tool page keeps the product overview here and routes deep technical material to GitHub.

Previous: Naming Convention Utility Next: Smart Content Diet