FModel for macOS

An unofficial native macOS (Apple Silicon) port of FModel, the archive explorer for Unreal Engine games, built on CUE4Parse with an Avalonia UI. The app is called FModel and follows the original's layout and features as closely as macOS allows.

This project is not affiliated with or endorsed by the FModel authors or Epic Games. Please report problems with this port here, not to the original FModel.

Features

• Explorer: Pak and IoStore archives (encrypted, compressed, unversioned with mappings), the Archives / Favorite Directories / Folders / Packages tabs, FModel's new asset explorer (grid and list with thumbnails), search, references and metadata.
• Games: profiles (each with its directory, UE version, AES keys, mappings, endpoints, language and favorite directories), AES and mappings endpoints (uedb.dev presets), versioning overrides, backups and comparison with FModel's online backups.
• Previews: properties as JSON, textures, decompiled Blueprints and Lua, localized texts, an audio player (Wwise, Bink, ADX/HCA, Opus… through vgmstream) and an image merger.
• 3D viewer (OpenGL): static and skeletal meshes with PBR materials and normal maps, maps and landscapes with their layers, navigation meshes (UE's cooked navmesh data and Detour navmesh set .bin files, by area, over the map when one is open), an orbit and a fly camera, animations, blend spaces and morph targets, the animations made for a mesh's skeleton with their notifies (sounds played in sync, an approximate preview of Niagara and Cascade effects), screenshots and video export (MP4/MOV with the notify sounds).
• Export: raw data, properties, textures, models (glTF, UEFormat…), animations, worlds and audio, per package or per folder, through an Export Session window.
• Command line and MCP server: fmodel lists, searches, reads and exports from the terminal, and fmodel mcp lets AI assistants (Claude Code, Claude Desktop, any MCP client) browse a game, read its packages and textures, and export assets, all with the profiles and settings saved in the app.

The full list, with the design decisions and how each part was verified, is in app/README.md.

Download

Get FModel-<version>-macos-arm64.zip from Releases, unzip it and move FModel.app to Applications. It needs a Mac with Apple Silicon and macOS 14 Sonoma or later; nothing else to install.

Opening it the first time

FModel isn't notarized by Apple (that takes a paid developer account), so macOS blocks it the first time:

1. Open FModel. macOS says it can't verify the app: click Done (or OK), not Move to Trash.
2. Open System Settings › Privacy & Security, scroll down to Security and click Open Anyway next to the message about FModel.
3. Open FModel again and choose Open Anyway; macOS asks for your password or Touch ID.

From then on it opens normally, and so does the fmodel command line. If you prefer the Terminal, this does the same: xattr -dr com.apple.quarantine /Applications/FModel.app.

Updates

Like FModel, the app looks for a newer release at launch (on GitHub, this repository's releases) and shows an Update Available button when there is one. Help › Releases lists every release; its Remind Me button silences the check for a few days, a week, a month, or for good. After an update, the first launch shows the new release's notes in a tab.

Requirements to build

• A Mac with Apple Silicon (arm64) and macOS 14 or later.
• The .NET 10 SDK, Xcode command line tools (xcode-select --install), git and cmake (CUE4Parse's native library is built with it).

Building

git clone https://github.com/arleckk/fmodel-mac.git
cd fmodel-mac
scripts/setup-upstream.sh --with-vgmstream
app/packaging/build-app.sh

setup-upstream.sh fetches the pinned FModel and CUE4Parse sources into upstream/ (not tracked) and applies patches/CUE4Parse.patch; --with-vgmstream also builds vgmstream for the audio player. build-app.sh produces app/dist/FModel.app. app/packaging/build-unluac.sh optionally adds the Lua decompiler. The app is signed ad hoc; a build made on your own Mac opens without the Gatekeeper prompt, since only downloaded files are checked.

Oodle-compressed games need nothing extra: CUE4Parse decompresses Oodle with OodleSharp (managed code, MIT), and no Oodle library from Epic Games Tools is included.

Command line

The app's executable is also a command-line tool. Put its fmodel link on your PATH (zsh):

echo 'export PATH="/Applications/FModel.app/Contents/Resources/bin:$PATH"' >> ~/.zprofile

If you downloaded the app, open it once from Finder first (see above), so macOS lets it run. Then:

fmodel profiles                                  # the games saved in the app; * is the active one
fmodel search Hero_Body                          # find files in the active profile's game
fmodel cat /Game/Characters/Hero/Hero            # a package's properties, as FModel's JSON
fmodel export /Game/Characters/Hero --kind models -p "My Game"   # glTF into ~/Documents/FModel/Output/Exports
fmodel ls -d ~/Games/MyGame/Content/Paks -g GAME_UE5_4 -k 0x… Game/Content     # a game without a profile
fmodel export Game/Content --kind all           # every kind but raw data, for a whole folder
fmodel backup                                    # the game's file list, as a .fbkp in Output/Backups
fmodel diff latest                               # what's new or modified since the newest backup
fmodel export --since latest --kind textures     # only the new or modified files (no path = the whole game)

fmodel help lists every command and option. The command line reads the app's profiles and settings (Settings › Export decides the formats) and never changes them.

MCP server

fmodel mcp is an MCP server over stdio: an AI assistant can browse a game, search it, read packages as FModel's JSON, decompile Blueprints, find references, look at textures and export assets. It mounts the active profile (or --profile <name>) and keeps it mounted.

Claude Code:

claude mcp add fmodel -- /Applications/FModel.app/Contents/MacOS/FModel mcp

Claude Desktop and other clients (claude_desktop_config.json or the client's equivalent):

{
  "mcpServers": {
    "fmodel": {
      "command": "/Applications/FModel.app/Contents/MacOS/FModel",
      "args": ["mcp"]
    }
  }
}

Every tool only reads the game except export_assets, which writes into the app's output folder (or the folder you give it), and create_backup, which saves the game's file list as a .fbkp. compare_backup and export_assets with since tell or export what changed since a backup.

Where it keeps things

• Settings, profiles, favorites and caches: ~/Library/Application Support/FModel/
• Logs: ~/Library/Logs/FModel/ (the command line and the MCP server write FModel-cli-<date>.log)
• Exports (by default): ~/Documents/FModel/Output/

Repository layout

Folder	What
app/	The app (FModel), the test harness (FModel.Snapshot) and packaging scripts. See app/README.md.
poc/	The first proof of concept (CUE4Parse on macOS). See poc/README.md.
patches/	Our changes to CUE4Parse, applied on top of the pinned commit.
scripts/	setup-upstream.sh recreates the untracked folders; save-patches.sh refreshes the patch.
docs/	Images for this README.

Not tracked (recreated by the scripts): upstream/ (FModel at d615497 with CUE4Parse at 3fc091a, plus the patch) and vendor/ (vgmstream, unluac and their dependencies).

After changing anything under upstream/CUE4Parse, run scripts/save-patches.sh and commit the patch.

License and credits

As a derivative of FModel, this project is licensed under the GNU GPL v3.0 (see LICENSE); third-party components and their licenses are listed in NOTICE.

• FModel by 4sval and contributors (GPL-3.0): the features, interface and resources (icons, syntax definitions) this port is based on. If you find it useful, consider supporting FModel.
• CUE4Parse by FabianFG and contributors (Apache-2.0): reads the game files; our changes are in patches/CUE4Parse.patch.
• OodleSharp (MIT), vgmstream, unluac and the libraries listed in NOTICE.

Unreal Engine is a trademark of Epic Games, Inc. Game files and assets belong to their publishers; this tool doesn't include any.