FabTap

Key features

Requirements

Installation

FabTap ships as a project plugin. Drop the folder into your project's Plugins/ directory and restart the editor.

1. Copy the plugin Place the FabTap folder (the one containing FabTap.uplugin) at:

   <YourProject>/Plugins/FabTap/

2. Regenerate project files C++ projects only: right-click your .uproject and choose Generate Visual Studio project files. Blueprint-only projects skip this step.
3. Launch the editor On first launch Unreal will offer to compile FabTapEditor. Accept. The module loads in the PostEngineInit phase and registers the nomad tab plus the toolbar button.
4. Verify Open Window → FabTap, or click the branded FT button on the level editor toolbar. You should land on the embedded Fab.com browser or the Epic sign-in screen.

60-second quick start

The happy path, end to end, for a user who already has a Fab account:

1. Open FabTap Click the orange FT button on the toolbar, or use Window → FabTap.
2. Sign into Fab.com The embedded browser loads fab.com. Sign in the way you normally would. FabTap's OAuth token is negotiated in the background the moment you click Add to Project on any listing.
3. Find a pack Use fab.com's own search, filters, and category pages — everything works, including paginated results and asset detail views.
4. Click Add to Project FabTap intercepts the click, resolves the pack's signed manifest URL, and starts a BuildPatchServices install. A toast confirms the download is running.
5. Wait for the two toasts The first says "Download complete". The second — a few seconds later — says "Relocated N assets to /Game/…". You're done.
6. Open the folder The Content Browser jumps to your destination folder automatically. All imports, redirectors fixed up, references intact.

Opening the panel

FabTap registers three entry points into the editor:

• Window menu — Window → FabTap
• Toolbar button — the orange FT icon in the level editor's play-toolbar row
• Keyboard — the tab is a standard FGlobalTabmanager nomad, so any layout shortcut you've bound to it applies

The tab is a NomadTab, so you can dock it anywhere in your layout or tear it off to a second monitor. The layout is preserved between sessions via Unreal's standard tab-layout persistence.

Authentication

FabTap authenticates with Epic using the standard OAuth2 authorization-code flow, then forwards that token to Fab's services for library queries and signed manifest URLs.

Primary: loopback redirect

1. Click Connect Epic Account The plugin spins up a local HTTP listener on localhost:6789.
2. Sign in via system browser Your default browser opens Epic's login page. Complete sign-in and 2FA if prompted.
3. Token exchange Epic redirects to http://localhost:6789/?code=…. The listener captures the code, exchanges it for an access + refresh token, and closes the tab.

Fallback: paste code manually

If localhost:6789 is blocked (corporate firewall, VM networking quirks) the UI exposes a Paste authorization code field. Copy the code= query parameter from the browser URL after signing in and paste it in. Same token exchange, no loopback required.

Native Fab.com browser

The default — and strongly preferred — interface. When the panel opens, you're looking at the real fab.com webapp embedded via Unreal's WebBrowser module (Chromium Embedded Framework). Everything fab.com can do in a real browser, it can do here: search, filters, paid listings, free listings, My Collection, library, categories.

The click-interception magic

FabTap injects a small JavaScript poller into each fab.com listing page. When you click Add to Project, the normal fab.com request fires as usual — but its signed manifest URL is captured by FabTap and the download is handed off to the native installer instead of the Epic Games Launcher.

You never leave the editor. The launcher never opens. The install runs in a toast, not a separate window.

What gets intercepted

Legacy "My Library" tab

FabTap originally shipped with a second tab, My Library, that used Epic's legacy entitlement APIs to list owned content directly — bypassing fab.com's webapp. That path is still present in the codebase but is hidden by default for v1 because the legacy surface is incomplete:

• Many Fab-native listings don't round-trip through the entitlement API and show blank or with stale metadata.
• Selective-import dependency expansion is only implemented on the Browse side.
• Users who land on the Library tab by mistake hit dead ends.

You can re-enable it for diagnostics or if you specifically prefer the legacy path:

Editor Preferences → Plugins → FabTap → Advanced
    [x] Show Legacy "My Library" Tab

When disabled (the default), the top tab strip is hidden entirely and the panel opens straight into the embedded fab.com browser. The underlying library cache, catalog enrichment, and asset-type lookup still run in the background — only the tab button is suppressed — so the Imported only filter and the per-type routing continue to work.

Searching & filtering (legacy library)

These filters apply to the legacy My Library tab. On fab.com itself, use the fab.com filters — they're more comprehensive.

All search and filtering runs in-memory against the cached library. No network round-trips; results appear instantly as you type.

Catalog metadata (asset type, tags, engine version, thumbnail) is enriched in background batches of 5 requests at a time to avoid rate limits. Tiles update in place as enrichment completes — no full rebuild required. The first-launch enrichment cap is tunable (InitialEnrichmentCap) for users with huge libraries.

Installing a pack

The normal v1 path is click Add to Project in the embedded browser. That triggers the full native install pipeline. Here's what happens:

1. Signed URL capture FabTap's JS poller spots the fab.com API response, extracts the signed manifest URL, the catalog item id, and the asset's pretty type. The click proceeds through fab.com's own stack too, but its normal "open launcher" redirect is suppressed.
2. Concurrency check If the same catalog item is already installing — from any source — a toast says so and the second click is ignored. Prevents two pipelines racing to write the same files.
3. Manifest fetch The .manifest blob is pulled from Epic's CDN. Both chunked (modern BPS) and monolithic (legacy Marketplace) layouts are handled. If you close the editor here, an OnPreExit hook cancels the request cleanly.
4. Staging & marker Files stream into <Project>/Saved/FabTap/staging/<CatalogItemId>/. A .fabtap_active marker is dropped so the storage sweep never deletes an in-flight install.
5. Dependency expansion Every downloaded .uasset header ImportMap is walked. Engine, /Script/, installed plugins, and in-project /Game/ references are skipped. External Fab-owned references are queued for a supplementary fetch.
6. Native import The staged tree is copied into the pack's native /Game/<PublisherFolder>/ path first, so references resolve. The asset registry scans.
7. Relocation UAssetTools::RenameAssets moves everything into your per-type install root (see Per-type install routing). Redirectors are fixed up. The now-empty publisher folder is pruned from both disk and the Content Browser.
8. Done A toast confirms, the Content Browser jumps to the destination folder, and the staging directory is cleared.

Dependency resolution

The dependency resolver classifies every reference in an asset's ImportMap into one of four buckets:

Recursion is capped by DependencyResolutionMaxDepth (default 5, clamp 1–20). If the cap is hit mid-walk, a warning surfaces in the log and preview dialog so you can raise the cap and re-run.

Both pre-UE5 and UE5+ package summary layouts are parsed — the first four bytes (PackageFileMagic) select the branch. Soft references, editor-only references, and localised-content references are considered optional and noted rather than fetched.

Download queue

The queue shows every in-flight install with a progress meter, a cancel button, and the current BPS status string (staging, downloading, moving, finishing). Downloads are orchestrated by BuildPatchServices on a background worker; file writes are atomic — nothing partial ever lands on disk.

Settings reference

All settings live at Editor Preferences → Plugins → FabTap and persist to <Project>/Config/EditorPerProjectUserSettings.ini. Settings are per-project-per-user by design — every team member can pick their own install paths.

Import

Download

Cache

Advanced

Per-type install routing

FabTap classifies every pack by its primary Fab taxonomy label (VFX, Environments, Blueprints, Characters, …) and routes it into a folder you choose. This replaces the flat /Game/FabTap/ dumping-ground model with whatever organisation makes sense for your project.

Setting it up

1. Open settings Editor Preferences → Plugins → FabTap → Import → Install Roots By Asset Type.
2. Quick-start with defaults Click Reset Routes To Defaults. You'll get the sensible starting layout below, slotted under your current DefaultImportPath.
3. Customise Each row is a dropdown-picked type key + a free-form destination path. Add rows for any types you want to customise; remove rows you don't. Unmapped types fall back to DefaultImportPath.

Default route layout (produced by Reset Routes)

Code Plugin and Complete Project are deliberately omitted from the reset — they're usually project-wide installs, not per-asset drops. Add custom entries if you want routing for them.

How type classification works

FabTap reads the asset type from Fab's library metadata at the time of install. The value is case-insensitive: vfx, VFX, and Vfx all match the same route. Missing or unrecognised types fall back cleanly to DefaultImportPath — no pack ever fails to install because its taxonomy label wasn't in your map.

Routing is pack-level, not asset-level. A mixed Environment pack that happens to ship VFX inside stays in one piece at Environments's route — the dependency walker keeps references intact either way thanks to the post-import reference fixup.

Flattened layouts

By default, every pack installs to /Game/<InstallRoot>/<PackName>/…. The <PackName>/ segment isolates packs from each other so two VFX packs shipping NS_Fire.uasset don't fight.

For type-pure, low-collision content (VFX, HDRIs, Audio, Materials, Textures), that isolation is often just noise — you'd rather have one unified VFX folder than a dozen pack-named subfolders. FabTap supports dropping that isolation on a per-type basis via FlattenedAssetTypes.

What flatten does

Flatten drops two layers: the pack-name folder and the pack's publisher folder. The pack's internal structure (Niagara/, Meshes/, Materials/) is preserved because it's author-intended organisation.

The collision trade-off

Good candidates to flatten

• VFX — atomic Niagara systems, one-off effects.
• HDRIs — just cubemaps, no cross-reference risk.
• Audio — standalone sound cues and soundwaves.
• Textures — provided your texture packs have distinctive names.
• Materials — if you curate your library to avoid generic M_Base-style names.

Bad candidates — keep these un-flattened

• Environments — multiple environment packs ship identical SM_Rock_01, M_Grass, T_Noise, &c.
• Complete Project — whole-project bundles that depend on internal cohesion.
• Blueprints — Blueprint systems often have same-named managers, interfaces, or enums.
• Characters / Vehicles / Weapons — cohesive bundles where pack provenance matters.

Configuring it

Editor Preferences → Plugins → FabTap → Import
    Flatten Pack Name For These Asset Types
    [ VFX   ]
    [ HDRIs ]
    [ Audio ]

Empty by default. Dropdown-picked from the same taxonomy used elsewhere.

Architecture

FabTap is a single editor module (FabTapEditor) composed of focused singletons. All HTTP callbacks are marshalled back to the game thread before firing public delegates.

Module layer breakdown

• SFabTapPanel — root Slate panel; hosts the tab strip, filter bar, tile grid, detail pane, and download queue.
• SFabTapFabBrowserPanel — embedded CEF browser, JS injection, signed-URL interception, unsupported-type feedback.
• FFabTapFabBridge — the JS ↔ native glue that turns intercepted clicks into installer jobs.
• FFabTapFabInstaller — BuildPatchServices driver, IsInstalling registry, .fabtap_active marker, PreExitDrain.
• FFabTapFabManifestPrefetch — downloads and caches .manifest blobs ahead of user click for snappier UX.
• FFabTapFabDependencyExpander — walks .uasset ImportMaps for modern Fab packs.
• FFabTapFabStagingImporter — moves BPS-downloaded files from Saved/FabTap/staging/ into /Game/<PublisherFolder>/.
• FFabTapAssetRelocator — per-type routing + flattening + rename + redirector fixup + ghost-folder sweep.
• FFabTapDownloadManager — legacy chunk fetcher for pre-BPS Marketplace packs.
• FFabTapImporter — legacy import path (file writes under Content/, registry scan).
• FFabTapDependencyResolver — pre-BPS ImportMap parser used by the legacy tab.
• FFabTapApiClient — all HTTP traffic, response parsing, retry + refresh-on-401.
• FFabTapAuthManager — OAuth2 flow, token persistence, silent refresh.
• FFabTapSearchIndex — in-memory library, filter evaluation, catalog enrichment, asset-type lookup for routing.
• FFabTapStorage — staging / thumbs / cache sweeps, marker-file-aware so it never deletes an active install.
• UFabTapSettings — UDeveloperSettings-backed preferences persisted to EditorPerProjectUserSettings.ini.

Install pipelines

Two pipelines coexist; the native one is the default path and the legacy one is a fallback for the hidden library tab.

Native BPS pipeline (default)

Triggered by clicking Add to Project in the embedded fab.com browser. Uses Epic's BuildPatchServices module — the same code the Epic Games Launcher uses — for chunked, resumable, delta-aware downloads. This is the fast, reliable path, fully tested in v1.

Legacy chunk pipeline

Triggered from the hidden My Library tab's Download button. Uses FFabTapDownloadManager with parallel HTTP chunk fetches against the CDN. Retained for compatibility with pre-Fab Marketplace packs; not wired up behind the default UI.

Both pipelines share the same relocator, settings, and storage sweep code, so routing and flattening behave identically regardless of which one triggered the install. This will only have assets prefab purchase or added main work flow should use the main Fab extension side

Concurrency & safety

FabTap takes shutdown-safety and cross-pipeline coherence seriously. The practical guarantees:

No duplicate installs of the same asset

FFabTapFabInstaller::IsInstalling(AssetId) is checked before any install starts — from either the browser click-intercept or the legacy Download button. A duplicate click surfaces a toast ("Install already in progress.") instead of racing two pipelines against the same destination. The legacy button is also disabled (greyed out with "Installing…" text) while an install is running for that asset, from either source.

Marker-protected staging

Every active install drops a .fabtap_active marker into its staging directory with the PID, asset id, and start time. The storage sweep (accessible from the settings menu) respects markers younger than 24 hours: fresh markers protect their staging dir; stale ones (older than 24 hours) or missing ones allow the normal 1-hour age cutoff to apply. You can't accidentally "Clear Staging" a download that's still running, even one that's been going for three hours on a slow connection.

Shutdown drain

A FCoreDelegates::OnPreExit hook (FFabTapFabInstaller::PreExitDrain) fires if you close the editor mid-install:

• Flips an IsShuttingDown() flag that every in-flight HTTP callback consults before touching BPS.
• Calls Cancel() on every live installer instance.
• Guarantees the Finalize() path is idempotent via a bFinalized latch, so late callbacks re-entering after cancel don't double-fire.
• Uses TWeakPtr captures in HTTP callbacks so a destructed installer is detected and skipped cleanly.

Net effect: no BPS assertions, no half-written files, no orphaned threads — even if you kill the editor three seconds into a download.

Rename-hostile asset skip

The relocator knows certain asset classes don't survive UAssetTools::RenameAssets in a clean state. Worlds (Levels) are the main offender — their streaming data, lighting cache, and HLOD builds break in ways that are hard to detect post-rename. These classes are identified in IsRenameHostile() and left at their native /Game/ path with a surface warning rather than silently corrupted.

API endpoints

FabTap talks to the same services the Epic Games Launcher uses. Every response is parsed by the plugin — nothing is forwarded blindly.

The primary Fab endpoint returns titles, images, engine versions, distribution method, and asset tags in a single response. The legacy library + catalog pair is retained as an automatic fallback if the Fab endpoint is unavailable, and is exposed in the legacy My Library tab when enabled.

On-disk storage

A Storage dialog accessible from the panel's settings menu exposes category-by-category clear buttons (thumbs, library cache, staging, auth). The staging sweep is the one to know about — it's the cleanest way to reclaim disk if a pack install failed partway through, and it's marker-aware so you can click it with an install in flight and not damage anything.

Troubleshooting

Sign-in never returns (should auto log in if fab is signed in a restart can fix this if hung up)

Another process is likely bound to localhost:6789, or a firewall is blocking loopback. Copy the code= query parameter from the browser URL manually and use the Paste authorization code field.

Embedded browser is blank on first open

CEF can take a few seconds to spin up on a cold editor launch. If it's still blank after ~10 seconds, check Output Log for LogWebBrowser errors. Disabling the WebBrowser engine plugin by accident is the usual cause; re-enable it in Edit → Plugins → WebBrowser.

"Add to Project" does nothing

The JS poller may not have attached in time, or fab.com changed its DOM. The click still works — fab.com will try to open the launcher. If the launcher opens instead of FabTap catching the install, close the launcher, refresh the fab.com page, and try again. The listing will still be interactive so you never lose the ability to install manually through the launcher as a last resort.

Toast says "Only Unreal Engine packs are supported in v1"

You clicked Add to Project on a non-UE asset (gltf, fbx, metahuman, environment-lite, etc.). Those formats aren't wired through the BPS installer yet. Look for the UE-native version of the same pack on fab.com, or use the standard launcher for non-UE types in the meantime.

Toast says "Install already in progress"

Working as intended — you clicked Add to Project on an asset that's already installing from another source (browser + legacy tab concurrently). Wait for the first one to finish, or cancel it from the download queue.

Imports fail with HTTP 401 repeatedly

Your refresh token has expired. Sign out from the panel's settings menu and reconnect. If it happens immediately after a fresh sign-in, your system clock may be more than 5 minutes off — Epic's OAuth rejects tokens outside a tight time window.

Downloads stall near completion

Lower MaxParallelChunkDownloads to 2 or 3. Some ISPs and corporate proxies throttle bursts of short HTTPS connections; BPS doesn't slow-start on its own.

Asset imported but doesn't show in Content Browser

FabTap triggers ScanPathsSynchronous after every install. If the content browser is stuck, right-click the destination folder and choose Refresh. If the issue persists, restart the editor and confirm files were written under Content/<your install root>/.

Pack installed but wrong folder

Check three things in order: (1) was a route configured for this pack's asset type? (2) was the type detection correct — you can check LogFabTapRelocator for the "Routing pack X (type Y) to /Game/Z" line; (3) is Relocate Imports Into Install Root enabled? Also note that flatten mode bypasses the per-pack subfolder — if you enabled it for that type, your pack's files go directly under the install root, which is the intended behaviour.

Half-relocated pack after enabling flatten

Collision with another pack. Check LogFabTapRelocator for "Rename failed — target exists" warnings. The clashing assets stay at their native /Game/<PublisherFolder>/ path. Either rename them, delete one of the duplicates, or turn flatten off for that type and re-import.

Dependency preview warns about truncation

The resolver hit DependencyResolutionMaxDepth. Increase the setting, re-open the preview, and the warning should disappear.

Editor crashed mid-install — what now?

Nothing should be broken. Relaunch the editor. On startup, the storage sweep will see the stale .fabtap_active marker (over 24 hours is stale), and the 1-hour staging-age cutoff will clear the partial download on the next Clear Staging. Re-trigger the install — BPS will start fresh. In-progress-but-partially-relocated packs stay where they are; you can delete them manually or re-import to the same destination.

Live Coding blocked the build

FabTap includes a Build.cs and is compiled into FabTapEditor. If you're iterating on the source and Live Coding is active, finish the Live Coding session (Ctrl+Alt+F11) or close the editor before running a full build.

FAQ

Does this replace the Epic Games Launcher?

Only for Fab library browsing and per-asset installs inside an open UE project. The launcher is still required to install the engine itself, to manage purchases, and for non-UE asset types (gltf, fbx, metahuman).

Is this against Epic's terms of service?

FabTap uses the same authenticated endpoints the official launcher uses, with your own OAuth credentials, and downloads only content your account is entitled to. Use at your own risk — Epic can change or restrict these APIs at any time.

Does FabTap work with Marketplace (pre-Fab) content?

Yes. The legacy monolithic manifest path is handled automatically. Such packages are downloaded as a single blob via the BPS pipeline and their files are extracted and relocated like any other pack.

Can I use FabTap in a build pipeline / CI?

The plugin is editor-only — its module declares Type: Editor so it's never cooked into a packaged game. Headless use would require a saved auth.json and commands invoked via Python/automation, which is not officially supported in v1.

Why is the legacy "My Library" tab hidden by default?

The legacy entitlement API the Library tab uses is incomplete — many Fab-native listings show blank or with stale metadata there, and selective-import dependency expansion is only implemented on the Browse side. The embedded fab.com browser covers every case the Library tab covers, plus everything the Library tab doesn't. Turn on Show Legacy "My Library" Tab in Advanced settings if you want it back for diagnostics.

Can I change the destination path per import?

Yes — configure Install Roots By Asset Type. Every asset type (VFX, Environments, Blueprints, …) can have its own destination. Unmapped types fall back to DefaultImportPath.

Can I flatten just one asset type?

Yes — add that type to Flatten Pack Name For These Asset Types. Every other type keeps the per-pack subfolder. Read Flattened layouts first — collisions are the one real gotcha.

Can I re-install a pack to pick up new routing / flatten settings?

Yes. Delete the existing installed folder first (or it'll be skipped as "already installed"), then click Add to Project again. FabTap honors the current settings at install-time, so a re-install picks up whatever the active routes are.

Will FabTap survive if fab.com changes its UI?

Partially. The JS click-interception poller is best-effort and will log and give up gracefully if the DOM shape changes. The underlying endpoints (manifest fetch, CDN auth) are stable launcher APIs and far more resilient. Worst case: fab.com stops auto-installing but remains fully usable as a regular browser tab while the poller is fixed.

Where are thumbnails stored?

Under <Project>/Saved/FabTap/thumbs/, keyed by catalog item id. Safe to delete — they'll be re-fetched on demand.

How do I sign out?

Settings menu inside the panel → Sign out. Or delete <Project>/Saved/FabTap/auth.json manually. The embedded browser's cookies are separate — to clear Fab.com's own session, sign out inside the browser too.

Does CEF/WebBrowser ship in my packaged game?

No. The FabTapEditor module is declared Type: Editor, so the WebBrowser dependency (and CEF along with it) is only linked into editor builds. Packaged runtime targets never see FabTap or its dependencies.

Credits & license