| Title | Support | Engine command | Bind file | In-game test |
|---|---|---|---|---|
| Microsoft Flight Simulator 2024 | native | engine msfs2024 | your own profile the sim uses per device and category (Steam remote\inputprofile_* XML or the Microsoft Store save, --user-profiles) + JoyPro's Community package (joypro-input-profiles, one preset XML per device); import files in Documents\JoyPro2\MSFS 2024 import files where your profile cannot be written | 26/26 |
| Microsoft Flight Simulator 2020 | native | engine msfs2020 | Steam userdata\<id>\1250410\remote\inputprofile_* (XML fragment per device) | 41/41 |
The game page in plain words: Microsoft Flight Simulator 2020, Microsoft Flight Simulator 2024. Full matrix: Game support. What an export does in this kind of game: Export flow, in the game.
From docs/games/msfs.md in the repository (generated, always the current text).
MSFS 2024 in short: the sim takes JoyPro's preset package only for aircraft it has no own settings for that device yet. It also makes such settings without a flight, so aircraft you never flew can have them already (a test PC, 2026-11-01: settings for 56 aircraft, none flown). For every other aircraft, use your own profile (the export writes it) or the import file JoyPro writes per device: Settings > Controls > device > category > cogwheel of the profile > Import (see "Getting the binds into the sim").
#Two games: MSFS 2020 and MSFS 2024
JoyPro handles the two sims as two games side by side (both can be installed at the same time):
MSFS 2020 (MSFS2020) |
MSFS 2024 (MSFS2024) |
|
|---|---|---|
| CLI | engine msfs2020 (fs2020) |
engine msfs2024 (fs2024; old name msfs) |
| Install | Steam app 1250410 (FlightSimulator.exe), Store Microsoft.FlightSimulator_8wekyb3d8bbwe, %APPDATA%\Microsoft Flight Simulator |
Steam app 2537590 (FlightSimulator2024.exe), Store Microsoft.Limitless_8wekyb3d8bbwe, %APPDATA%\Microsoft Flight Simulator 2024 |
Export target (paths) |
the Steam remote folders of app 1250410 (inputprofile_*); the Store version's profiles are imported, not written |
JoyPro's preset package Community2024\joypro-input-profiles, then the Steam remote folders of app 2537590; the export to the package also writes your own profiles the sim uses (Steam remote folder or Microsoft Store save, see "Writing your own MSFS 2024 profiles") and import files where those cannot be written (Documents\JoyPro2\MSFS 2024 import files (2.2.7: Documents\JoyPro, moved at the next export), see "Getting the binds into the sim") |
| Process (export refused while it runs) | FlightSimulator |
FlightSimulator2024 |
| Catalog | DB\MSFS2020\actions.tsv |
DB\MSFS2024\actions.tsv |
| Aircraft list | DB\MSFS2020\aircraft.tsv (for example 44 aircraft) |
DB\MSFS2024\aircraft.tsv (81) |
refresh-db reads |
MSFS 2020's presets (<install>\Input, its Official packages) and locPak |
MSFS 2024's presets (fs-input-profiles, asobo-input-profiles-pc) and locPak |
Both use the same code (engine\Games\MsfsIntegration.cs, one instance per sim) and file reader, so either game
still reads and writes a profile file or folder of the other sim's format when it is given with --path. The axis
model is msfs for both (tuning scopes game:MSFS2020, game:MSFS2024, and family:msfs for both). Both catalogs
started as the shared catalog of the single MSFS game (built from both sims' data); each refresh only adds its own
sim's actions. The aircraft lists come from the same discovery (both sims are read: a streamed 2024 aircraft takes its
title from the same 2020 package), each game keeps the aircraft of its sim.
Profiles and settings saved before the split (game MSFS) are migrated when they are loaded
(engine\Games\LegacyGameIds.cs): a node MSFS:<action>[:<aircraft>] becomes an MSFS2024 and an MSFS2020 node with
the same aircraft; game:MSFS tuning becomes family:msfs. A folder set for "Microsoft Flight Simulator" in Settings >
Games goes to the sim it belongs to (FlightSimulator.exe, 1250410 or the 2020 Store package -> 2020, else 2024),
"I do not have MSFS" hides both. engine msfs ... and --node MSFS:<action> still work (MSFS 2024, and a node per
sim). Ownership data and backups stay in %LOCALAPPDATA%\JoyPro2\Ownership\MSFS / Backups\MSFS (kept per file
path). The watcher's records (<data>\Sync\MSFS.json) are not carried over; the next export records each sim again.
#Files
- 2020 Steam:
<Steam>\userdata\<id3>\1250410\remote\inputprofile_<10 digits>(XML, no extension).profile_00(binary) maps device instance GUIDs to the inputprofile files. Steam Cloud folder. - 2020 MS Store:
%LOCALAPPDATA%\Packages\Microsoft.FlightSimulator_8wekyb3d8bbwe\SystemAppData\wgs\...containers; blobs are renamed on every save. Read only (imported, see below). - 2024 Steam:
<Steam>\userdata\<id3>\2537590\remote\inputprofile_*. 2024 Store:Microsoft.Limitless_8wekyb3d8bbwe\SystemAppData\wgs\.... Both are written by the export since 2026-10-20 (the profile the sim uses per device and category, see "Writing your own MSFS 2024 profiles"). - 2024 supported route: Settings → Controls → cogwheel → Export/Import (same controller and same category only). [SRC MS support]
- 2024 JoyPro route: Community package (
engine\Games\MsfsCommunityPackage.cs). MSFS 2024 loads device presets from packages; Asobo ships the presets of known sticks that way (<install>\Packages\asobo-input-profiles-pc,fs-input-profiles). Each preset is plain XML underInputProfiles\Categories\<Airplane|Glider|Helicopter|LighterThanAir|Other|Transversal>\with root<DefaulftInput Primary="1" PlatformAvailability="PC">and<Device DeviceName GUID ProductID="C215" CompositeID HWVer>. The sim matches a preset to a device by the USB product ID (hex). A preset lists only the bound actions. The package also haslayout.json(every file with size and FILETIME date) andmanifest.json(package_order_hint: INPUT). The exe confirms the folder rules (InputProfiles/Categories/<Category>). [OBS, SRC SDK "Input Profiles"]- JoyPro writes
<packages>\Community2024\joypro-input-profiles\InputProfiles\Categories\Airplane\JoyPro_<device>_<guid8>_2024_Planes.xmlper device, then layout.json and manifest.json (builder: Microsoft Flight Simulator 2024).<packages>isInstalledPackagesPathin%APPDATA%\Microsoft Flight Simulator 2024\UserCfg.opt(Store:...\Microsoft.Limitless_8wekyb3d8bbwe\LocalCache\UserCfg.opt). Community2024 is the folder for packages built for 2024: the sim's session report (AsoboReport-RunningSession.txt) counts a package there undercommunityfolderfs24, and the same package inCommunityundercommunityfolderfs20. The config path formsfs export|import|scanis the Community(2024) folder or the package folder (engine msfs2024 pathslists it). - General binds (since 2026-10-19): a device with binds of the general contexts (cameras, views, active pause, ...;
the sim's "General" page) also gets
...\Categories\Transversal\JoyPro_<device>_<guid8>_2024_Transversal.xml, the folder Asobo's own presets use for them (asobo-input-profiles-pc\InputProfiles\Categories\Transversal\*_2024_Transversal.xml, no<AircraftInfo>, contexts such asCOCKPIT_CAMERA,EXTERNAL_CAMERA,MODES,INGAME_UI,VIEW_MODE_SWITCHES). The exe names the category foldersAirplane,Glider,Helicopter,LighterThanAir,Other,Transversal("... must be either ..."). General actions go only into the Transversal preset, flight actions only into the airplane preset; each keeps its context (the action's catalog category). - Encryption (since 2026-10-19): the package matches the EFS encryption of the Community folder it is in. A Microsoft
Store install on another drive keeps its data encrypted (EFS), and Windows refuses a plain file there: "The APPX
file can not be accessed because it is not encrypted as expected." (409, an EFS refusal; report on 2.2.1, MSFS 2024 Store). JoyPro
2.1.1 to 2.2.1 removed the mark from the package before every export (meant for the 6000 case below), which caused
it. Now the export never removes the EFS mark of the package; when the Community folder is encrypted it first repairs the package
(
MsfsCommunityPackage.MatchFolderEncryption/SafeFileIo.MatchFolderEncryption):File.Encrypt(EFS) on every folder and file that lost the mark; a file Windows does not EFS-encrypt is read, deleted and written again (it takes the folder's mark); a file that cannot even be read is moved to<data>\Backups\MSFS\package-<time>(deleted when that fails) and the export makes it again (a warning names the device presets that were reset; the binds come from the JoyPro profile; earlier copies are in JoyPro's backups). New preset files are written into the folder and take its mark. Everything done is logged (MSFSlog area). Not verified on a real Store install on a second drive (no such PC); the simulated EFS states are covered bySafeFileIoTests, real EFS by the opt-inJOYPRO_TEST_REAL_EFS=1. - When Windows cannot EFS-encrypt a folder (2.2.5 report, MSFS 2024 Store):
File.Encrypt(EFS) failed on every package folder with "The request is not supported.", so each export deleted the unreadable presets and wrote them again into folders without the EFS mark: plain again, unreadable again (409) for the sim and JoyPro (the export then found "no MSFS profile of device ..."). The preset files made while the folders still had the EFS mark stayed readable, so a new file or folder made in an EFS-encrypted folder takes its EFS mark there. Now such a folder is made again (SafeFileIo.RebuildFolder): a new folder beside it (checked: it must carry the EFS mark, else nothing changes), EFS-encrypted files moved over (they keep their EFS mark), readable plain ones written into it, unreadable ones moved out of the way as before, then the new folder takes the old name. Files in a folder without the EFS mark are no longer deleted and written again (it would not help). What still fails is a warning that says to delete the package folder with the sim closed and export again (EFS: the folder made then takes the Community folder's mark). The step "encrypted (EFS) again" counts only what worked. Test:SafeFileIoTests.MatchFolderEncryption_FoldersWindowsCannotEncrypt_AreMadeAgain. - Import of an own preset Windows cannot read (EFS, 409): the import first tries
File.Encrypt(EFS) on it; else it reads JoyPro's newest readable copy (<data>\Backups\MSFS\<file>.<time>.jpbak, made by an export before it writes the file, or<data>\Backups\MSFS\package-<time>\<file>) with a warning: the sim does not use the file either (no EFS mark), the binds come from the copy, export once to write it again. Without a copy the warning says that its binds were not imported and to import with "Merge into profile" (not--replace), then export. The device is not taken as "no own profile" when the copy was read (no default preset over it). Test fault:JOYPRO_TEST_FAULT_ENCRYPTION=read:409:<file name>(simulated EFS refusal); testMsfsProfileImportTests.Store2024_PresetsTheSimsRecordsDisagreeOn_AreNotImported_UnreadableOwnPresetFromJoyProsCopy. - Product ID: the one the sim noted for the device in profile_00 (read only), else the USB PID. The sim sees vJoy as product ID 0 (not 0xBEAD); real sticks match their USB PID (WINWING 0xBE04, VKB 0x0125).
- Axis settings go into each action as a per-action override (flag 4096 +
<Axis/>): the sim ignores a preset's<Axes>block. The device page (Hardware Settings) stays per device. - No
DeviceConfig.xml: an entry without a display name renamed the device to "Unknown Device" in the sim. - A device needs its product ID, so it must be connected for the first export. The preset is created once and reused. New actions go into their catalog context.
- When the sim uses the preset (in-sim check 2026-10-10): the sim keeps one record per device and aircraft in profile_00 and fills it with the device's default preset when it creates it (first time that device is configured for that aircraft). The vJoy test preset showed exactly the exported random binds for an aircraft the sim had not configured yet (Cessna 185: flaps down button 7, rudder RAXIS Y, ailerons LAXIS Y, elevator RAXIS X, nav lights button 13). For an aircraft already configured with that device the old record stays (empty or the previous preset). Only Controls > Reset to Defaults (End) re-applies the defaults, and it resets the presets of every device and aircraft ("Your custom profiles will not be deleted"), so JoyPro does not do it.
- JoyPro never edits profile_00: the file ends with a checksum, and a changed file made the sim discard the whole profile (new profile_00, "Connect to Xbox Network" with account linking on the next start). The original file put back fixed it.
- JoyPro writes
- Getting the binds into the sim (since 2026-10-19, 2.2.6 report, MSFS 2024 Store): "MSFS does not recognise any
new relations generated from JP": relations made in JoyPro never showed up in Controls. Cause: the package preset
applies only where the sim has no record yet (above), and a user's profile_00 (read only, copy) has records for
every connected device in every aircraft the user flew: VMAX throttle, MOZA AB9, Total Controls MFBB and VPC Panel #2 with
their own profiles (slot flag 3,
inputprofile_<n>) or with no preset, the T-Pendular-Rudder on its shipped preset, the MFDs on theirs. So JoyPro's presets reached only aircraft the user had never used with a device. The Store keeps the user's own profiles in its save containers, which JoyPro did not write before 2.2.9 (now it does: "Writing your own MSFS 2024 profiles").- Import files (
engine\Games\MsfsIntegration.ImportFiles.cs): every export to the package (not a dry run) also writes, per device and category with binds, a profile in the sim's own format intoDocuments\JoyPro2\MSFS 2024 import files(<JOYPRO_DATA_DIR>\MSFS 2024 import fileswhen set):<device>_<guid8>_Airplanes.xml/_General.xml. Base: the user's newest own profile of that device and category (Steam remote folder or Store save, read only), so the user's other binds and the listing stay; JoyPro's binds go in by the export mode and ownership (kept per import file). Without an own profile: a new profile (<Version Num="-1"/>,<FriendlyName>,<Device DeviceName GUID ProductID>with the decimal product ID the sim noted or the USB PID,<AircraftInfo CategoryName="AIRPLANE"/>for airplanes) listing every action of the command list for the category. The name is "JoyProAirplanes|General". A step per file says what the sim does with the device now (from its records: "the sim keeps its own settings of this device for N aircraft ... import this file"), and the export ends with the steps: Settings > Controls, pick the device and the category (Airplanes or General), the cogwheel of the profile (not the preset's; report on 2.2.7) > Import, pick the file (the sim imports only a file of the same device and category). A step lists the files that are new or changed since the last export (only those need importing again). The GUI (Other Games, Export) shows the folder with "Open folder" and these steps. Test: MsfsProfileImportTests.Store2024_Export_WritesImportFilesPerDeviceAndCategory(Store save unchanged, dry run writes none). - Since 2026-10-20 the export writes the user's own profiles (next section); the import files are written only
for a device and category JoyPro could not update there (
--import-files/ GUI "Also write MSFS import files for every device": always). An import file of a device whose active profile JoyPro knows carries that profile's name (<FriendlyName>): the sim's Import then asks "a profile with that name already exists, overwrite?" and Yes puts the binds into the user's profile (report, MSFS 2024 Store; Import creates a new "JoyPro ..." profile otherwise). The step says so ("Import it and confirm 'overwrite': your profile 'X' then has JoyPro's binds"). Every bind goes into the category the sim lists its action in (the user's own profiles list every action of their contexts:KEY_ACTIVE_PAUSE_TOGGLEis inINGAME_UI, a General bind, also when the shared command list has it inPLANEfrom MSFS 2020; report "Active Pause not in the sim"), and the file is read back: a bind that did not land is named ("not written:( ) (General) - "). - Not verified in the sim: that its Import takes these files (format as its own profiles and exports; the menu path from the MS support article and the in-game help); not checked on a real Store install. - Re-import of JoyPro's own relations: relations made before 2.2.6 ("Microsoft Flight Simulator 2024
") are matched by node, not by name: an import into such a profile (user's copy, 28 relations) added only the 2 new binds and kept every old name.
- Import files (
- 2024
profile_00(Steamremote): a binary tree. A node is an 8-byte name hash, a uint32 size (header included) and a payload: a container holds a uint32 count and child nodes, a leaf holds a value (strings NUL-terminated). 2020 uses the same format. The tree holds:- a device table (instance GUID string, type);
- per device, the category scope (AIRPLANE) and the aircraft scope (
asobo-aircraft-c172sp-as1000); - per device and aircraft, three preset slots (general = transversal, category, aircraft), each with the preset
file name (
keyboard_2024_planes.xml; empty = none). [OBS 2026-10-10] - field hashes (2026-10-19,
engine\Games\MsfsSimProfile.cs): instance GUIDe494a07827809546(string; keyboard and mouse a number), typec5e29153ab70ce33(1 joystick, 15 keyboard/mouse), product ID9c6a107054980963, composite ID419c4be1028db14a, preset filee5374a443ee0986e, categorydd0e07ae6ad0a4fc, aircraft6ef48b11820c125d; slotsae7f5b37a56a781c(general),8b57821791389404(category),6bc4c835749736a7(aircraft) inside a record that carries the device fields itself. The file ends with 5 bytes after the tree. - more fields (a user's Store profile_00, 2026-10-19): slot flag
00d10becc027d54f(0 none, 1 shipped preset, 3 own profile: the preset field then holdsinputprofile_<n>and the name field its name), display name877ddf5aa523fd04(the preset's name, "TT:GENERIC.NONE" for none; often empty, also for the keyboard on the test PC's Steam copy, so it is not used), aircraft patha8df1050ac9f14e5. Under the root containera532ec6925941962:a46c8bf66a7db8ce(per device a general entry),4f1fd58aaa70b44e(per device and category),7af6b80fdb235d3f(per device and aircraft) all with empty preset fields on both PCs, anda9281cff465213e7(the records, one per device and aircraft configuration). Old device instance GUIDs keep their records.
- 2024 in-game observations (Steam, 2026-10-10, menus only):
- The Steam
remotefolder holds onlyprofile_00,localprofileanddatausage(binary), and noinputprofile_*, until a preset exists. No XML profiles under%APPDATA%\Microsoft Flight Simulator 2024. - A device without a preset (vJoy) shows no preset selector and no preset gear. Its device gear only offers Rename / Deactivate / Hardware Settings, so there is nothing to export until one bind creates a preset.
- The help page says: preset management is the gear next to the preset selection; binding = select the action, click an empty slot (shows "Scanning..."), then move the axis.
- The scan takes the first input of any device. A device that keeps sending (a VPforce Rhino FFB stick: the Control listener shows SLIDER X/RX changing with nobody touching it) makes the slot show "WRONG DEVICE", and the bind never happens.
- Hardware Settings (device gear) = device-level curves per axis (Sensitivity +/-, Neutral, Dead zone, Extremity Dead Zone, shown as 0.00) with a live dot on the curve: a menu-only way to check curves without a flight.
- Per-action settings (row gear): input repetition, delayed input, set on release, inverted axis, current axis value, input value override, device input curve override, tweak action curve.
- The Steam
- Default device profiles:
<install>\Input\*.xml. - Cloud (Steam, Xbox, 2024 server) can revert local edits. New
inputprofile_*files are not picked up (profile_00 references specific files): only edit existing ones.
#Writing your own MSFS 2024 profiles (since 2026-10-20)
A user's report (MSFS 2024 Microsoft Store): importing JoyPro's file in Controls worked but made a second profile "JoyPro engine\Games\MsfsIntegration.UserProfiles.cs) now
writes the profile the sim uses for every device and category of the export; --user-profiles false (GUI: "Write into
my MSFS profiles", on by default, remembered in export-settings.json) turns it off. JoyPro's package presets stay (they
reach aircraft the sim has not set up for a device yet).
- Which profile is active: the sim's device records (profile_00: Steam
remote\profile_00, Store containerprofile_00; read only) hold per device and aircraft a General slot and a category slot; an own profile there has flag 3 and the nameinputprofile_<n>, which is the Steam file name and the Store container name. Per device and category every own profile the records name is written (Airplanes: the category slot of the records with category AIRPLANE; General: the general slot), each for the aircraft of its records (see "Per-aircraft binds"). On the user's save every VMAX record (4 aircraft) namesinputprofile_0674863296("Iain's VMAX Prime General") andinputprofile_1407711872("Iain's VMAX Prime Airplane"). Aircraft-specific slots are not written, profile_00 never, and JoyPro makes no new profile. No record or none naming an own profile: no direct write, the import file has the binds (with the reason). - Editing: the line-based
MsfsProfileFileeditor with the export modes as for MSFS 2020, per profile (so per aircraft): only add skips and reports a bind on a combination another action of that profile has; merge replaces that action's combination (the conflict) and keeps the rest; merge-overwrite also takes the actions the export binds for that profile's aircraft (binds limited to aircraft count only for profiles of those aircraft) off their other combinations, also in the profiles of other connected devices that hold them (those profiles are written too).--nuke-untouched-devicesnever clears a user's profile. Ownership (per profile, for the Store by save and container) only keeps the device axis pages JoyPro wrote apart from the user's. - Microsoft Store save, write side (
engine\Games\WgsContainers.cs; format of the read side above): checked first (index version 14, no unresolved-conflict flag (16), the container listed once with state 1 synced, 2 modified or 5 created, the state fitting its cloud version tag,container.<n>with exactly one blob, blob ids equal unless the state is modified, the blob there with the index's size, the index reading back byte for byte); anything else writes nothing (import file instead, reason in the result). Then, per changed profile: a new blob file named by a new GUID,container.<n+1>(255 wraps to 1) with the cloud's blob id kept and the new file as on-disk id, thencontainers.indexonce (temp file + replace): entry number n+1, size, time (milliseconds), state 1 -> 2 (2 and 5 stay), the cloud version tag (ETag) unchanged; header time max(now, old + 1), flag "fully uploaded" (1) cleared (3 -> 2), count and the other bytes unchanged. Order blob, container file, index last, so an interruption leaves the previous generation complete. Read back (index, container, blob as written; the profile parses with the same device, category and action count), then the supersededcontainer.<n>and blob are removed (the game keeps one of each per folder). A failure after the first write deletes the new files and puts the index back. Other containers (profile_00, logbooks, other profiles) and other titles are never touched. Write layout as libNOM.io (No Man's Sky save library,PlatformMicrosoft_Write.cs: container number + 1, synced -> modified, index sync state "modified", the old cloud blob id in the first slot) and GamePassStorage (docs/wgs-format.md: states, flags, write order, strictly growing index time). Verified on a copy of a user's real save (21 containers): JoyPro's write changed exactly the two entries and the two profile blobs (a 5-line XML diff each, ATC Panel Choice 0 on button 2 into the General profile, gear into the Airplanes profile), the index re-parses with every other byte equal, JoyPro's own reader and a second write (state 2, ids differing) work. - Safety: the whole export is refused while
FlightSimulator2024runs; the direct write also while the GDK launch helper (gamelaunchhelper.exewith "Flight Simulator", "Limitless" or "MSFS" in its path, or a path that cannot be read) runs. Before the write every file of the save's user folder goes into the run's backup set (index last; the new files are recorded as new), soengine backups restore <set>/ Export > Game config backups put the save back. A restore marks the containers it changed as modified on this PC (newest cloud version tag kept, newer index time, "fully uploaded" cleared), else the Xbox sync would see the old state as synced and download its newer copy. - Xbox cloud sync (risk): the Xbox app / Gaming Services upload a container in state "modified" the next time the sim starts (or the app syncs). A version written in the cloud by another PC after the last sync on this one makes a conflict: the sim or the Xbox app asks which save to keep; keep the one of this PC to keep JoyPro's binds (the other one drops them; export again). JoyPro refuses to write while the conflict flag is set. Not verified with a live sync.
- Steam (app 2537590): the Store container names are the file names of the sim's save layer (
profile_00,inputprofile_<n>,sr_logbook; a Steam install's remote folder holdsprofile_00,localprofile,datausage,sr_logbookand lists them inremotecache.vdf), and a Store profile blob is the same plain XML as 2020's Steam file. So a profile made in Controls isremote\inputprofile_<n>, named in profile_00 like in the Store save; the export edits that file in place (backup.jpbakand backup set first, read back, put back on failure). Steam Cloud uploads the changed file on the next sync. A Steam install without an own profile does not show this, so this is not checked with a real Steam profile (only the layout of the remote folder and the Store's names). - Result: per profile a line with its aircraft ("MSFS 2024 'VPC VMAX Prime Throttle' (General): your profile 'Iain's
VMAX Prime General' (C172, Bonanza G36): 6 bind(s) ..."), the JSON
ProfileUpdates(device, category, profile, the aircraft, status updated / unchanged / dry-run / import-file, reason, binds, not written), shown on the Start and Export pages ("Your MSFS 2024 profiles"). Logging:MSFSarea (sources, the active profile per device and category, each container's old and new number and blob, the index time and flags, failures with the reason),Backups,Diagnostics(NoteReadof every profile read,BeforeWriteof every file). - Tests:
MsfsProfileImportTests.Store2024_Export_WritesTheActiveProfilesInTheSave,..._RelationDeletedInJoyPro_...,..._SimRunningOrUnknownIndex_WritesNothing_ImportFilesInstead(stand-ingamelaunchhelper.exe/FlightSimulator2024.exe),..._FailureRollsBack_BackupRestoreRoundTrip(JOYPRO_TEST_FAULT_WGS=blob|container|index),..._MixedCategories_...,Store2024_BindDeletedInTheSim_IsRemoved_PackagePresetDoesNotBringItBack,Steam2024_Export_WritesTheActiveRemoteProfile,Store2024_Export_UserProfilesOff_ImportFileNamedLikeTheActiveProfile,Steam2024_PerAircraft_EveryProfileGetsTheRelationsOfAllItsAircraft_ImportTicksThem. - Per-aircraft binds (since 2026-10-20): MSFS 2024 keeps the profile choice per device and aircraft, so the relations
can be limited to aircraft like in DCS: the relation editor lists the aircraft of
DB\MSFS2024\aircraft.tsvwith checkmarks for an MSFS action (engine relations aircraft [set]; every aircraft ticked = all aircraft, the node's game key; some ticked = exactly those, as node AIRCRAFT keys). Export with the direct write (IGameAircraftScope.WritesLimitedPerAircraft, the binding'sAircraft): a relation for all aircraft goes into every profile the records name; a limited one only into the profiles whose aircraft are all ticked. Ticked for only some aircraft of a shared profile: not written there, with a warning by name ("'X' is only for C172, but your profile 'Iain GA' is also used by Bonanza: not written there. Give the C172 its own profile in the sim (Controls, with the C172 loaded: duplicate the profile), then export again"). Ticked aircraft without an own profile in the records: a step names them. The sim's record aircraft are the catalog keys (MsfsAircraftCatalog.KeyOf); record aircraft the catalog lacks are listed in a step (refresh the DB). Limited relations never go into JoyPro's preset package or the import files (both apply to every aircraft);--aircraft <key>still writes the ones limited to that aircraft for all. Import / scan: several own profiles of a device and category that the records name are all read. Relations are general (all aircraft) unless the user splits them: a bind in only some of the profiles is imported for all aircraft too and listed in the result (JSONOnlyInAircraft: relation, action, device, input, the aircraft andLimitCommand; text "Only in the sim's profile(s) of C172, Bonanza:( ), imported for all aircraft. Limit: engine relations aircraft set " " --node MSFS2024: --only "|""), and the GUI shows a hint on the Relations page after the import with "Limit to these aircraft" per relation, "Limit all" and "Keep for all aircraft". relations aircraft set ... --only a|bticks exactly these aircraft. Limited right away (GameProfileBridge.ScopeNode): withmsfs2024 import --limit-to-profile-aircraft, for a node the user had limited already (game state wins), for a bind JoyPro exported (its metadata: a relation JoyPro exported for all aircraft is in every profile, so the sim's layout is the user's split; the export/import round trip keeps it), and for an action the catalog has only for some aircraft ("Add-on aircraft" below). Tests:MsfsProfileImportTests.Steam2024_PerAircraft_...(Steam save with a shared General profile and an Airplanes profile each for C172 and Bonanza: general relation in both, C172 relation only in the C172's, the shared-profile warning, the import round trip),Steam2024_BindOnlyInSomeAircraftsProfiles_IsImportedForAllAircraft_AndListedToLimit. Not done: per-aircraft write into the aircraft slot (aircraft-specific presets of the aircraft's own package), MSFS 2020 (one profile per device). - Add-on aircraft (since 2026-10-20): aircraft of the Marketplace or the Community folder with controls of their own.
actions.tsvhas an optional sixth column, the aircraft keys an action exists for (id, title, kind, context, native id, a|b; empty = every aircraft). Filled by (a) import / scan: an action the user's profiles bind or list that the list lacks joins it with its context (any^[A-Z][A-Z0-9_]*$id, also withoutKEY_, e.g.PMDG_737_EFIS_CPT_MODE), and when only some of the own profiles of a device and category have it (one per aircraft), with the aircraft of those; (b)msfs2024|msfs2020 refresh-db(without--path), read only:MsfsGameData.AddonPresetPackagesreads the unpacked packages inCommunity/Community2024of the InstalledPackagesPath and inOfficial*\<store>\*(Marketplace / OneStore) with anInputProfiles\**\*.xmlfolder (Asobo's preset packages, fs-base and JoyPro's package excluded); their actions the list lacks join it, for the package's aircraft when its manifest sayscontent_typeAIRCRAFT (key as inaircraft.tsv), else for all. A package without InputProfiles that holds only packed.fsarchivearchives (JoyPro does not read them) is skipped and named in the step ("1 packed package(s) skipped (.fsarchive, not readable: ...)"). The sim's own actions stay general. Relation editor: a search row of such an action says "only for:", and adding it ( relations add/relations item addwith no aircraft in the node) ticks those aircraft alone: the only case JoyPro splits on its own, since the action exists only there. The import limits a relation of such an action to those aircraft too, without listing it. Test:Steam2024_RefreshDb_ReadsAddonPackagePresets_ActionsTaggedWithTheirAircraft(synthetic Community2024 aircraft package with a preset, a packed .fsarchive package). Not checked against a real add-on (none was at hand): the ids and contexts real add-ons use in their presets are unverified; lowercase ids would be left out. - Import, scan and the watcher's diff read the user's own profile as the truth of its device and category: JoyPro's package preset of the same device and category is not read beside it, and a package preset of a device the sim has records of counts only where a record names it (a user deleted ATC Panel Choice 0 in the sim, the diff showed 0 changes; an import into a clean profile brought back two JoyPro-made relations the sim shows nowhere). With several own profiles of a device and category the one the records name wins over the newest. A Community2024 folder given as the export path means the package (one watcher record; an export there and an import kept two, and the diff compared with the older baseline).
#Import of your own profiles (since 2026-10-17)
A user report (MSFS 2024, Microsoft Store) failed with "The JoyPro MSFS 2024 package has no presets yet": import read
only JoyPro's own preset package, and a fresh install had no command list. Now import and scan (engine msfs2024|msfs2020 import|scan, GUI import wizard) read what the user set up in the sim (engine\Games\MsfsUserProfiles.cs):
- Steam: every
<Steam>\userdata\<id>\<app>\remote\inputprofile_*(2020: 1250410, 2024: 2537590). - Microsoft Store / Xbox app:
%LOCALAPPDATA%\Packages\<family>\SystemAppData\wgs\<user>\(2020Microsoft.FlightSimulator_8wekyb3d8bbwe, 2024Microsoft.Limitless_8wekyb3d8bbwe). The Xbox "connected storage":containers.index(uint32 version, int32 count, uint32, string package name, FILETIME, uint32, string, uint64; per container: name, name again, quoted hex id, byte file number, uint32, folder GUID, FILETIME, 16 bytes; strings are int32 length + UTF-16LE) lists the containers;<folder GUID>\container.<n>lists the blobs (uint32 4, int32 count; per blob 64 UTF-16 characters of name, file GUID, the GUID again); a blob is the file named by its GUID (32 hex digits). Format as the Store-save tools document it [SRC XGP-save-extractor]; not checked against a real MSFS Store install (none was at hand). Every listed blob whose content is an input profile is read (plain XML, UTF-16 with BOM, or zlib/gzip-compressed, decompressed into<data>\Cache\MSFS\wgs); an index of another layout makes JoyPro check every GUID-named file instead (warning). The engine is a .NET Framework program: paths over 260 characters are not read (a real blob path is about 205 characters plus the user name). - JoyPro's package (
Community2024\joypro-input-profiles) is read besides; its absence is no error. - Per device and category one profile:
--game-profile <name>, else the most recently saved one (a warning names the others). JoyPro's presets and the user's profiles are chosen separately. Keyboard/mouse/gamepad profiles (GUID="{0}") are counted, not imported; binds of every managed context are imported, flight and general ones (see "Managed contexts"; only menu, world map and developer binds are counted and left out); axis tuning (device Sensitivity page, per-action override, invert, no-curve flag) as before. Flight actions are read first, so an input bound to a flight and a camera action (throttle axis and cockpit zoom) gives a relation named after the flight action; an axis the file inverts for one of them and not the other becomes two relations (one relation has one invert). - An action the user binds that the command list lacks is added to it (
actions.tsv) with its context as category (also actions withoutKEY_, such asDRONE_ZOOM_IN); the title is the sim's menu name (en-US.locPak) when the sim is installed, else one from the event name (KEY_COCKPIT_CAMERA_ZOOM_AXIS-> "Cockpit Camera Zoom Axis"). An action the list has in a flight context that a profile of this sim binds in a general one (the shared list hasKEY_ACTIVE_PAUSE_TOGGLEin PLANE from MSFS 2020; MSFS 2024 binds it inINGAME_UI) gets the general context, so the export writes it into the Transversal preset. - Unbound actions too (since 2026-10-19, 2.2.6 report): the relation editor found only "ATC Panel Choice 0/1" and
"Display ATC" for "atc", while the sim lists ATC PANEL CHOICE 0 ... 9: a user's command list was built by an
older JoyPro (flight contexts only) and an import added only bound actions. A user's MSFS 2024 profile (Steam, Store,
an exported file; not a preset) lists every action of its contexts, unbound ones as empty
<Action/>, so import and scan now add every listed action of a managed context with the context the sim lists it in (title from the locPak), and give a known action whose context the sim lists only elsewhere (general) that context (KEY_PUSHBACK_SET: PLANE from MSFS 2020,SIM_SHORTCUTin 2024); flight contexts are never moved. Menu, world map and developer contexts stay out (KEY_ATC_MENU_OPENis listed only inDEBUG). On a user's copy (8 profiles of connected devices): his list 1399 -> 2007 actions after one scan. Test:MsfsProfileImportTests.Store2024_UnboundActionsTheProfilesList_JoinTheCommandList. - Devices that are not connected (since 2026-10-19): MSFS keeps a profile of every device it ever saw (Store saves,
Steam remote files) while the sim lists only the connected ones; a 2.2.1 import brought relations of four devices the
user no longer had. Import and scan now take the profiles of connected devices (the profile's instance GUID among
the connected DirectInput devices) and name the others in a step ("Profiles of N device(s) that are not connected were
left out ...").
--include-disconnected(GUI: "Also import devices that are not connected" on the import wizard and the Other Games form, off by default, remembered with the export settings) imports them too. With no device connected at all everything is imported (with a note), so an import on another PC still works. The watcher's automatic import uses the default. MSFS only: the other games keep one bind file without a per-device history, so they do not have this problem and keep their import as it was. - Devices on the sim's default preset (since 2026-10-19): MSFS saves a device's profile only once the user changes
something; an untouched device runs on the preset the sim ships for it. A 2.2.3 import (MSFS 2024) brought only the
four devices the user had customized, not their T-Pendular-Rudder (brakes L-Axis Y / X, rudder L-Axis Z, sidebar
"T-Pendular-Rudder presets config"). Now import and scan (
engine\Games\MsfsSimDefaults.cs) take, for every connected device and category without an own profile, the default preset the sim uses: the shipped presets (MsfsGameData.PresetFiles: 2024fs-input-profiles,asobo-input-profiles-pc,InputProfiles\Categories\<Category>\*.xml) matched like the sim does, by the hexProductIDof<Device>(the one the sim noted for the device in profile_00, else the USB PID; the sim's ownInputProfiles\DeviceConfig.xmlalso lists devices byProductIdonly; theGUIDandDeviceNameof a shipped preset are Asobo's, not the user's), the preset withPrimary="1"(Primary="0"are the alternatives of the preset selector). Categories: Airplane and Transversal (General). Order: the user's own profile of that category, then JoyPro's package preset, then the shipped default. Presets without a device GUID (keyboard, mouse, gamepad) are left out; when several primary presets share the product ID with differentCompositeID(VelocityOne Flight: yoke and quadrant) none is taken and a step says so. Each device gets a step ("T-Pendular-Rudder: no own MSFS profile, imported the sim's default preset 'T-Pendular-Rudder 2024 Planes' (Airplanes)"). The preset's<Axes>page is not imported as tuning (the sim ignores it); invert flags are. Not with--path <file>or--game-profile. With no saved profile at all the import no longer fails when defaults were found (otherwise a step adds that none of the connected devices has a default preset). Read only: the shipped presets are never written; export goes to JoyPro's package as before (the defaults are written there like any other bind). Checked 2026-10-19 on a Steam install: 100 airplane and 78 transversal presets; none of the connected devices there (VKB 231D:0125, Virpil 3344:80CB, WinWing 4098:BE04, MFG, VPforce, vJoy) has one, a TPR (044F:B68F) and a Logitech Extreme 3D (C215, also a Transversal preset) given as test devices got theirs. MSFS 2020: same code over its presets (no categories); its shipped presets were not checked on a real install (none was at hand), so a 2020 preset must also carry the device's name. Test:MsfsProfileImportTests.Steam2024_DevicesOnTheSimsDefaultPreset_AreImported(fixtureengine\tests\fixtures\msfs\shipped-presets). - Only presets the sim really uses (since 2026-10-19, after 2.2.4): a 2.2.4 import (MSFS 2024 Microsoft Store) gave a user relations
for their two Thrustmaster MFD Cougar panels from their shipped presets, while the sim shows no binds for them.
Evidence (MSFS 2024 install, read only): the MFD presets look like the TPR's:
MFD_COUGAR_Left_2024_Planes.xml(ProductID="B351", also a Transversal one) andMFD_COUGAR_Right_2024_Planes.xml(B352, no Transversal one; Left and Right have their own product IDs),Primary="1"likeT-Pendular-Rudder_2024_Planes.xml(B68F), andDeviceConfig.xmlhas the same kind of entry for all three (ProductId+TextureFolder, no flag). So the shipped files cannot tell why the sim applies one and not the other. What the sim applies is in profile_00: per device and aircraft the three preset slots (general, category with its category name, aircraft) each hold the file name of the preset the sim applies, in lower case (keyboard_2024_planes.xml,mouse_2024_transversal.xml), or a 0 byte; a flag beside it is 1 when a preset is set. On a Steam profile_00 the keyboard and mouse slots name their presets in 52 airplane / 61 transversal records, the slots of the 13 joysticks (none with a shipped preset) are all empty. 2.2.5 report (same user, Store): the MFDs still came in, because one record named their presets. His profile_00 (read only, copy): the current T-Pendular-Rudder (044F:B68F) has 4 records (Bonanza G36, C172 cargo, C172 passengers, A320neo), the category slot of every one namest-pendular-rudder_2024_planes.xmlwith the display name "T-Pendular-Rudder 2024 Planes", general slot none ("TT:GENERIC.NONE": no Transversal preset), aircraft slot none. F16 MFD 1 (B351) and MFD 2 (B352) have 4 records each: in 3 the general (MFD 1) and category slots carry flag 1 with an empty file (a state seen nowhere else), only the A320neo record namesmfd_cougar_left_2024_transversal.xml/mfd_cougar_left_2024_planes.xml(MFD 2:mfd_cougar_right_2024_planes.xml) without a display name, its aircraft slot "TT:GENERIC.NONE". The per-device entries outside the records are empty for all three (also for a keyboard that runs on its preset), and "TT:GENERIC.NONE" in an aircraft slot also sits beside the VMAX throttle's own profile that the sim uses, so neither marks "none". The sim does not use the MFD presets (no binds in Controls), so a preset counts only when the records agree. Rule (MsfsSimProfile.csrecords,MsfsSimDefaults.ForConnectedDevices/Votes):- per device and category the records vote: General = the general slot of every record; Airplanes = of the records with category AIRPLANE the aircraft slot when it names a file, else the category slot (2020: the first slot that names one);
- all name the same shipped preset: imported (also an alternative the user picked in the sim);
- none names one: no import, and when the device has a shipped preset a step says so ("F16 MFD 1: the sim has a default preset 'MFD COUGAR Left 2024 Planes' (Airplanes) but does not use it ...");
- some do, some do not (or different ones): not known, not imported, a step: "F16 MFD 1: the sim's records of this
device (one per aircraft) name its default preset 'MFD COUGAR Left 2024 Planes' (Airplanes) in only 1 of 4, ...";
--include-sim-defaultstakes the one most records name ("(--include-sim-defaults: the sim's records name it for 1 of 4 aircraft)"). On that copy: the rudder's preset is imported, the MFDs get nothing. - no records of the device or none of that category (no profile_00 found, a format JoyPro cannot read): unknown, not imported, a step names the
preset and the opt-in:
--include-sim-defaults(GUI: "Also import default presets the sim may not use" beside "Also import devices that are not connected", import wizard and Other Games page, remembered inexport-settings.json), which takes the Primary preset of the product ID as before. The opt-in never overrides records that all name no preset. - profile_00 sources:
<Steam>\userdata\<id>\<app>\remote\profile_00and every blob of the Store save folder whose content (plain or zlib/gzip-compressed) is the same tree (a step says which were read). The Store blob was not checked against a real Store install (none was at hand): a user's TPR keeps its preset by default only if his Store profile_00 is found and names it; otherwise the opt-in brings it back. Tests:MsfsProfileImportTests.Steam2024_DevicesOnTheSimsDefaultPreset_AreImported(rudder and throttle named, MFD slots empty),..._WithoutTheSimsRecords_DefaultPresetsOnlyOnRequest_StoreRecordsAreRead(profile_00 built like the sim's, also as a compressed Store blob) andStore2024_PresetsTheSimsRecordsDisagreeOn_AreNotImported_...(the 2.2.5 records in minimal form: 4 aircraft, rudder named in all, MFD in 1).
- Skipped devices: the profiles of devices that are not connected are left out before JoyPro picks one profile per device, so "Device 'VPC CM3 Throttle' has 2 MSFS profiles; imported the most recently saved one" no longer appears for a device that was not imported (2.2.5 report).
- A user's case as a test (
MsfsProfileImportTests.Steam2024_GeneralBindsAreImported_...): VPC VMAX Prime Throttle with flaps / throttle 1 / throttle 2 axes (airplanes) and cockpit view zoom axis, reset / toggle cockpit view, toggle external view and active pause (General), plus an old MT-50CM3 stick that is not connected. - Nothing found: the error names every folder searched (package, Steam remote folders, the Store save folder with the number of saved files that were no input profile) and suggests Controls > cogwheel > Export + import of that file.
- Export: 2024 writes JoyPro's package and the import files (see "Getting the binds into the sim"; the Store version loads the package from its own Community2024 folder,
InstalledPackagesPathof...\Microsoft.Limitless_8wekyb3d8bbwe\LocalCache\UserCfg.opt), 2020 the Steam remote folder; an export with the Store save folder as its path is refused (the export to the package writes the Store profiles the sim uses, see "Writing your own MSFS 2024 profiles"). - Config watcher (
engine sync): besides the export target it watchesinputprofile_*of the Steam remote folders andcontainers.indexof the Store save folder (any container save changes it; an empty diff is accepted silently), andsync diffreads the game as import does. 2.2.6 report ("JP does not always detect changes made in-game"): a user's logs show MSFS 2024 "untracked" all day: the export's record failed ("Could not record the exported config of MSFS2024": a file of the package was refused by Windows, "not encrypted as expected", the EFS refusal of a Store install), and a game only imported had no record, so the watcher never watched it. Now a file Windows does not let JoyPro read gets a fingerprint stamp from its size and write time (EFS refusals no longer break the record orsync status), and an import of a game without a record records it. A Store save (new blob and container names, containers.index replaced in place or by rename) is reported once after the writes; a later write of the sim or the Xbox app after the game closed starts a new check. Tests:MsfsProfileImportTests.Store2024_WatcherRecord_SurvivesUnreadableFiles_AndASimSaveIsDetected,GameConfigWatcherTests.StoreSave_NewBlobNamesAndReplacedIndex_IsReportedOnce. 2.2.7 / 2.2.8 report ("no prompt came up in JP at all"): a user's logs show the chain working up to the diff: MSFS 2024 tracked and watched, containers.index deleted and created again on every save (also 3 to 8 s apart for ~15 s after the sim closed: the Xbox app),FlightSimulator2024found and its exit awaited,sync status"changed"; added binds were offered, but a bind removed in the sim gave "Diff MSFS2024: 0 change(s)" and was accepted silently (JoyPro's package preset for the same device and category still had it; the profile choice of the import reading is fixed separately). The rest of the chain is hardened: the Store save folder waits 10 s after its last write (also after the sim closed;SettleSecondsinsync status), so the Xbox app's rewrites give one check instead of one per write; any exe in the Store install folders (XboxGames\Microsoft Flight Simulator 2024\Content\,WindowsApps\Microsoft.Limitless_*) counts as the sim, whatever it is called (ProcessFolders); an import refreshes the watch list at once (before, only an export did) and also records the game when the path box holds a discovered path ("Detect"); the logs say why an installed game is not watched (untracked, no config), which watch folders, processes and settle time it got, how the sim was found, and what an empty diff compared (binds in the game and the profile, baseline). Test:MsfsStoreWatcherEndToEndTests(real engine and the GUI's watcher on a stand-in Store save and a stand-in sim process; added bind after an export, removed bind after an import, both taken over). Only a Store install shows: whether the sim's exe is alwaysFlightSimulator2024.exethere (the folder rule covers other names), and whether 10 s covers the Xbox app's sync on slow PCs. - Store installs of the sim itself:
<drive>\XboxGames\<Microsoft Flight Simulator[ 2024]>\Content(also the folders of<drive>\.GamingRoot) count as install roots for the catalog refresh. - Command list on demand: a fresh install ships no game lists. A scan, import or export of a registry game without
actions.tsvbuilds it first as refresh-db would (progress shown; a dry run keeps it in memory); MSFS also takes the user's own profiles when the sim's presets are not readable. Star Citizen's import/export builds its list the same way. Tests:JOYPRO_TEST_MSFS_HOME(stand-inLocal,Roaming,Steamfolders),JOYPRO_NO_CATALOG_BUILD=1;engine\tests\smoke\msfsuserprofiles.ps1,gui\JoyPro.Gui.Tests\MsfsProfileImportTests.cs, journey scenariomsfs-store-import. - Steam installs (2026-10-17): 2020 keeps one
inputprofile_*per device; a 2024 remote folder without a saved custom preset holds onlyprofile_00,localprofile,datausage. Where MSFS 2024 writes a custom preset made in Controls was not checked in the sim (the docs above expectinputprofile_*in the remote folder; the 2024 exe has no literalinputprofile_string, so this stays an assumption).
#Format (XML fragment: several top-level elements, read with ConformanceLevel.Fragment)
<?xml version="1.0" encoding="UTF-8"?>
<Version Num="1238"/>
<FriendlyName>Saitek Pro Flight X-55 Rhino Stick</FriendlyName>
<Device DeviceName="Saitek Pro Flight X-55 Rhino Stick" GUID="{738A3930-CD8E-11EA-8004-444553540000}" ProductID="8725">
<Axes>
<Axis AxisName="X" AxisSensitivy="0" AxisDeadZone="0"/>
</Axes>
<Context ContextName="PLANE">
<Action ActionName="KEY_AP_MASTER" Flag="2">
<Primary>
<KEY Information="Joystick Button 2">1</KEY>
</Primary>
</Action>
<Action ActionName="KEY_AXIS_ELEVATOR_SET" Flag="4">
<Primary>
<KEY Information="Joystick L-Axis Y ">1042</KEY>
2024 adds CompositeID, HWVer, <AircraftInfo CategoryName="AIRPLANE"/>, ValueEvent, Delay and per-action <Axis .../> overrides (need flag 4096). Axis attributes (misspelled): AxisSensitivy, AxisSensitivyMinus, AxisNeutral, AxisDeadZone, AxisOutDeadZone, AxisResponseRate (-1 default), range -100..100 [INF].
Keyboard combo: <Primary><KEY Information="Ctrl">162</KEY><KEY Information="Up">38</KEY></Primary>, alternative in <Secondary>.
#Flags [SRC Input Configuration XML Properties]
1 ANALOG, 2 DIGITAL, 4 AXIS, 8 NO_MOD, 16/32/64 MOD_CTRL/SHIFT/ALT, 128 MOD_INV (invert), 256 MOD_UP, 512 MOD_VALUE, 1024 NO_SENS_CURVE, 2048 RESET_ONCONTEXT_DISABLED, 4096 AXIS_OVERRIDE, 8192 MOD_PRESSED, 16384 DELAYED_EXCLUSIVE, 32768 NO_KEYBOARD_LAYOUT. Examples: 132 inverted axis, 8194 digital once, 4100 axis with override.
#KEY codes [OBS]
| Input | Code |
|---|---|
| Joystick Button N | N-1 |
| Pov Up/Right/Down/Left | 256/257/258/259 |
| Slider X / Y | 514 / 530 |
| R-Axis X / Y / Z | 770 / 786 / 802 |
| L-Axis X / Y / Z | 1026 / 1042 / 1058 |
| half axis L-X− / L-X+ | 1024 / 1025 |
| Keyboard | Windows VK codes (Shift 160, Ctrl 162) |
Scheme [INF]: base 0x100 POV, 0x200 slider, 0x300 R-axis, 0x400 L-axis; +0x10 per axis; low nibble 0 negative half, 1 positive half, 2 full axis. Information strings of axes end with a space. POV diagonals and a second POV are unknown. The docs say not to invent these values.
#Devices
GUID = DirectInput instance GUID (machine specific), ProductID = decimal PID, CompositeID for multi-part devices. Keyboard/mouse GUID="{0}". One profile file per device and profile.
#Flight contexts [SRC Input_Profiles]
AIRCRAFT, BASIC_CONTROL(_HELICOPTER/_LIGHTER_THAN_AIR), INSTRUMENTS_CONTROL, PLANE, HELICOPTER, GLIDER, LIGHTER_THAN_AIR, RUDDER_AXIS, SURFACES(_HELICOPTER/_LIGHTER_THAN_AIR), THROTTLE; 2024 also AIRCRAFT_PC, SURFACES_GYRO, AIRCRAFT_ACTIVE_INTERACTION, HELICOPTER_ACTIVE_INTERACTION. Everything else (cameras, MENU, MODES, DRONE, SLEW, DEBUG, ATC) is general.
#Managed contexts (since 2026-10-19)
Until 2.2.1 JoyPro read and wrote only the flight contexts; a user's cockpit view zoom axis, view toggles and active
pause (the sim's "General" page) were not imported. Now JoyPro manages every context except the sim's own navigation
and developer ones (MsfsIntegration.IsManagedContext):
- Left alone:
MENU,MENU_*(menu navigation),WORLDMAP_*(world map),DEBUG,DEVMODE*,EDITOR_*(developer mode and its editors),MISSION_FLOW_TOOLS. They are UI navigation and debug binds, not the user's flight setup; import counts them ("bind(s) in menu, world map and developer contexts left out"), export never changes them (also notclean/nuke: the import leaves them out, so a round trip keeps them). - General (managed): everything else outside the flight contexts, e.g.
ALWAYS,ATC,COCKPIT_CAMERA,COCKPIT_GLOBAL_CAMERA(_TRANSLATE),COCKPIT_INTERACTIONS(_LOCK),CURSOR(_MODE_SWITCHES),DRONE(_GLOBAL),EFB(_CORE),EXTERNAL_CAMERA,FIXED_CAMERA,HANGAR_CAMERA,INGAME_UI,INSTRUMENTS_CAMERA,MODES,MODE_PAUSE,PC_MODE_SWITCHES,PHOTO_MODE_*,PLAYER_CHARACTER_*,SIM_SHORTCUT,SLEW,SMART_CAMERA,TOOLBAR,USER_CAMERA,VIEW_MODE_SWITCHES(the contexts of Asobo's 2024 Transversal presets, checked 2026-10-19; real 2020 profiles bindKEY_COCKPIT_CAMERA_ZOOM_AXISinCOCKPIT_GLOBAL_CAMERA). A new context of a later sim is managed too. - Export writes a general action into its context: 2020 / Steam profiles in place (the context the action has in the folder's profiles, else its catalog category), 2024 package presets into the device's Transversal preset (see above). Ownership, merge rules and backups are the same as for flight actions.
#Action list
2024 profiles list every action of their contexts (unbound ones as empty <Action/>). 2020 profiles only hold bound actions: seed with the SDK Event IDs (KEY_ + name).
#JoyPro implementation (engine msfs2020 ..., engine msfs2024 ...)
- Config path: one profile file or a folder (Steam
remotefolder of 2020/2024, or a folder of 2024 exports).engine msfs2020 pathslists the 2020 Steam folders,engine msfs2024 pathsthe 2024 package and Steam folders; both also list the Microsoft Store save folder (...\SystemAppData\wgs) when there is one. Import reads the Store profiles of both sims. MSFS 2020's Store profiles are never written. MSFS 2024's are written by the export to the package (the profile the sim uses per device and category,--user-profiles, see "Writing your own MSFS 2024 profiles"); the Store save folder itself is refused as an export path in both sims. - 2024 workflow: run
engine msfs2024 export <Community folder>(GUI: the discovered package path) with the sim closed: it writes JoyPro's presets into the package and your binds into the profiles the sim uses (Steam remote folder or Microsoft Store save). Only for a device and category JoyPro could not update there (or with--import-filesfor all of them,--user-profiles falsefor none), import the files ofDocuments\JoyPro2\MSFS 2024 import filesin Controls (see "Getting the binds into the sim"). The old route still works for an exported file: Controls > cogwheel > Export,engine msfs2024 export <file>, then Import in the sim. 2020 Steam: edit theremotefolder with the sim closed. - Device = the
GUIDattribute (DirectInput instance GUID), so no connected device is needed; keyboard/mouse profiles (GUID="{0}") are skipped. - One profile per device (and 2024 category) is used: the one picked with
--game-profile <FriendlyName>, or the only one. Devices with several profiles are skipped with a warning listing their names. - Written: only actions in managed contexts (flight and general, see above) and in the catalog; only changed
<Action>elements are re-rendered. Axis binds set flag 4 and 128 (invert) and the axis settings below; a released 2024 action becomes an empty element again, a released 2020 action is removed. - KEY codes: buttons N-1, first hat up/right/down/left 256-259 (no diagonals), full axes X/Y/Z 1026/1042/1058, Rx/Ry/Rz 770/786/802, sliders 514/530. The last KEY of a combination is the main input, other buttons of the same device are modifiers; axes take no modifiers. Half axes are not read.
- New actions: 2024 files already list all actions of their category (an action no profile of the device holds, e.g. a General bind of a device without a Transversal profile, is reported once and skipped); in 2020 files the action is added to the context it has in the other profiles of the folder, else (general actions) its catalog context, else PLANE (with a warning). JoyPro's 2024 presets: general actions into the Transversal preset, flight actions into the airplane preset.
- Primary/Secondary: at most two input combinations per action; a third is reported and skipped.
- Export modes: only add writes a bind only where the profile has no other action on that combination (else it is listed under "Binds Not Written, Button Taken In The Game") and changes no bind that is there; merge replaces a combination the profile gives another action (the conflict) and keeps everything else, also a moved action's old combination (two slots per action); merge-overwrite also takes the actions the export binds off their other combinations in the profiles of connected devices; clean keeps only the export's binds in the profiles of the connected devices it writes, nuke clears the profiles of connected devices without binds. Profiles of devices that are not connected and the menu, world map and developer contexts are never cleared. Ownership (device axis pages only) and backups live in
%LOCALAPPDATA%\JoyPro2\Ownership\MSFSand...\Backups\MSFS, never in the Steam-synced folder.cleanonly changes profiles of devices that JoyPro binds in the export. The backups copy the bytes (SafeFileIo) into JoyPro's own folder: a Store-version export failed with "The specified file could not be encrypted." (2.1.0 report) whenFile.Copytried to keep a preset's EFS encryption. JoyPro's package keeps the EFS encryption of its Community folder (2.1.1 to 2.2.1 removed it, which broke Store installs on another drive with error 409; see "Encryption" above and backups). - Catalog:
DB\MSFS2020\actions.tsvandDB\MSFS2024\actions.tsv(each started as the same list: flight-context actions of MSFS 2024 airplane + helicopter exports and MSFS 2020 profiles). Input actions belong to contexts (AIRCRAFT, HELICOPTER, GLIDER, ...), not to an aircraft: a 2024 export lists every action of its contexts whatever aircraft is loaded, so the catalog is not tied to the test aircraft (Cessna 185). Axis actions are recognized by name (AXIS,*_SETof throttle/mixture/prop/surfaces). - Refresh from the game:
engine msfs2020 refresh-db/engine msfs2024 refresh-db(no path; GUI: Games > DB refresh without a source) reads the sims' own data, read only (engine\Games\MsfsGameData.cs): the device presets Asobo ships (MSFS 2024<install>\Packages\fs-input-profilesandasobo-input-profiles-pc,InputProfiles\**\*.xml; MSFS 2020<install>\Input; Store installs under theInstalledPackagesPathof UserCfg.opt,Official*\*) and adds every action of a managed context they bind, with its context (since 2026-10-19 also the general ones of the Transversal presets and the user's General profiles: cameras, views, pause, ...; an action the list has in a flight context that this sim binds in a general one moves to it; since 2026-10-19 also JoyPro's own package presets, and the context the user's 2024 profiles list an action in corrects one the list has from elsewhere; general events only the locPak names: see "General events only the locPak names" below); new actions get the Controls menu name fromfs-base\en-US.locPak(INPUT.KEY_...), known ones keep their title (import names relations after it) unless it is the raw event name (below).--path <folder>reads exported profiles instead. Readable titles (since 2026-10-12): the locPak writes the menu names in capitals; the catalog takes them in title case (ELEVATOR AXIS->Elevator Axis,THROTTLE 1 AXIS (-100 to 100%)->Throttle 1 Axis (-100 to 100%); the panel abbreviations stay:AP,NAV1,ADF,VOR,TACAN...). A known action still titled by its raw event name (AXIS ELEVATOR SET, the lists built before) is renamed too; every other known title stays. Without a locPak name (no locPak found, or an event it does not list) the title comes from the event name:KEY_AXIS_ELEVATOR_SET->Elevator Axis,KEY_THROTTLE1_AXIS_SET_EX1->Throttle 1 Axis(MsfsGameData.Readable/TitleFromEventName). The ids do not change, so relations, binds and exports are untouched; only relations made by a later import are named after the new title. The lists already on a PC get the readable titles with the nextrefresh-db(GUI: Games > DB refresh); nothing is renamed on load. Where the locPak is: Steam<MSFS 2024 install>\Packages\fs-base\en-US.locPak(2.2 MB, 2026-10), MSFS 2020%APPDATA%\Microsoft Flight Simulator\Packages\Official\Steam\fs-base\en-US.locPak(theInstalledPackagesPathof UserCfg.opt). Fresh build (2026-10-12, temp data folder): MSFS 2024 1715 menu names + 52 from the event name, MSFS 2020 1555 + 201. Every search hit carries the event id next to the title (Id); the relation editor finds the primary flight axes first (docs/relation-builder.md "Primary axes"). Since 2026-10-12 the refresh also adds every flight event the locPak names but no preset binds (most aircraft systems: autopilot, radios, lights, fuel, engines, G1000 and GPS keys, breakers, ...), so a fresh install does not depend on the user's exported profiles. The locPak names each event but not its context, so JoyPro's own rules decide (MsfsGameData.IsFlightEvent/GuessContext): not flight are cameras, views, menus, UI, developer mode, debug, photo mode, xCloud, slew, EFB, toolbar, ATC, cursor, VR, replay, multiplayer, the on-foot character, failures and blockages, recording; the context is LIGHTER_THAN_AIR (airship, balloon, burner), HELICOPTER (heli, rotor, collective, cyclic, auto hover), GLIDER (water ballast, tow plane), PLANE (the plane-only systems of the presets: liquid dropping, grapple hook, skydive lights, G limiter, ...), else AIRCRAFT. Fresh build (2026-10-12): MSFS 2024 1739 actions (presets 360 + 1379 named), MSFS 2020 1580; of the development list (from real exports) 1343 / 1195 ids are rebuilt, and the guessed context matches it for 91 % of the locPak-only events (most others are MSFS 2020 INSTRUMENTS_CONTROL rows of the shared development list). Check 2026-10-10 (2024 build of 2026-10-04): the 720 presets of both sims bind 1197 actions; every flight-context one was already in the catalog except 4 MSFS 2020 PLANE actions (back to fly, flashlight, pushback, UI window mode), now added. The locPak names 2736 KEY_ events; most of the rest are camera, menu, debug, VR and SimConnect-only events (e.g.KEY_AXIS_THROTTLE_SET; the 2024 Controls menu offersKEY_THROTTLE_AXIS_SET_EX1). General events only the locPak names (since 2026-10-19): with a full General profile of the user read (it lists every general action the sim offers) they stay out: the sim's menu does not offer them. Without one (a fresh install, Steam with no own profile) an event joins with the context of the known general actions sharing at least its first two name words, when two thirds of them agree (KEY_INSTRUMENT_LOOK_UP->INSTRUMENTS_CAMERAlikeKEY_INSTRUMENT_LOOK_DOWN;MsfsGameData.GuessGeneralContext), else it stays out. Checked against a full General listing of a user's profile: of the 720 general events only the locPak names, 490 sit in the sim's debug contexts, 170 in managed ones; the rule places 63 right and 14 wrong (mostly debug ones), the rest stays out; an import of a General profile later corrects a wrong guess. Counts (2026-10-19): a Steam install without own profiles: development list 1378 -> refresh 2165 before, 2420 now (ATC Panel Choice 0 ... 9 in both); with 18 Store profiles 2398 (no guesses: their General profile lists everything). Test:MsfsProfileImportTests.Refresh2024_LocPakOnlyGeneralEvents_TakeTheContextOfTheirNameGroup.
#Aircraft lists (DB\MSFS2020\aircraft.tsv, DB\MSFS2024\aircraft.tsv, engine\Games\MsfsAircraft.cs)
engine msfs2020|msfs2024 refresh-db (with or without --path; GUI: Games > DB refresh) also lists the installed aircraft of both
sims, read only, and merges the aircraft of its sim (column sims) into its DB\<MSFS2020|MSFS2024>\aircraft.tsv (aircraft found before stay, like the DCS planes; the file
ships with JoyPro as DCS's plane list does, and is written only when it changes, never on --dry-run).
- Identity (key) = the aircraft's package name without the
fs20-/fs24-prefix of the 2024 content list, e.g.asobo-aircraft-c172sp-as1000. [OBS 2026-10-10/11] MSFS 2024's profile_00 keeps its device x aircraft input records under exactly these names (asobo-aircraft-c172sp-as1000,microsoft-aircraft-c185f-skywagonfor the streamed packagesfs24-asobo-aircraft-c172sp-as1000/fs24-microsoft-aircraft-c185f-skywagon; read only from a copy). An MSFS 2020 package has the same name (Official\Steam\asobo-aircraft-c172sp-as1000), so one key covers both sims. One package can hold several SimObjects (floats, skis): they share the key (the 2024 record is per package too). [INF] Forfs20-packages that 2024 runs, and for Community packages, the record name is assumed to follow the same rule. - Sources:
- Package folders with
manifest.jsoncontent_typeAIRCRAFT(liveries areLIVERYand are left out, as are packages without an aircraft SimObject such as*-gliders-common):<InstalledPackagesPath>\Official*\<store>\*,Community,Community2024(UserCfg.opt of 2020 and 2024, Steam and Store) and<install>\Packages. Title = the manifesttitle(what the content manager shows), manufacturer = manifestmanufacturer(else the cfg'sicao_manufacturer).aircraft.cfg:SimObjects\<cat>\<obj>\aircraft.cfg(2020) and the 2024 modular files (...\common\config\aircraft.cfg,...\presets\<creator>\<preset>\config\aircraft.cfg); a cfg with[VARIATION] base_containeris a livery.[GENERAL] category(airplane/Helicopter; MSFS 2020 lists its gliders as airplane) andicao_type_designator; the user-selectable[FLTSIM.N] titles (isUserSelectable=0= AI traffic) are the variants (the sim's TITLE). Packed packages: theaircraft.cfgpaths inlayout.json(category from the SimObjects folder:Rotorcraft= helicopter). - MSFS 2024 streams its aircraft:
Official2024\Steamis empty andStreamedPackages\<package>holds only cached.fsarchiveparts, so there is no readable aircraft.cfg. The owned packages are listed in the content list<UserCfg folder>\<id>\Content.xml(<Package name="fs24-asobo-aircraft-c152" active="Activated"/>, alsoUserDisabled/SystemDisabled). JoyPro takes the activated-aircraft-packages that are no livery, no AI traffic (passiveaircraft), no base or shared package (fs-base-*,*-common,simattachmentlib,trainings,efb-app). Their title comes from the same package of MSFS 2020 when it is installed, else it is derived from the package name (C185F Skywagon; columntitle source=package name) and the category stays empty. Without a content list theStreamedPackagesnames are used.
- Package folders with
- Format (tab separated,
#comments):key, title, category, sims (2020,2024), icao type, manufacturer, packages (|), variants (|), title source (manifest | aircraft.cfg | package name). - Check 2026-10-11 (this PC, real refresh into a temp DB copy): 91 aircraft, 44 from MSFS 2020 (534 Official\Steam packages, 55 of type AIRCRAFT: commons and liveries left out) and 81 from the MSFS 2024 content list (61 aircraft packages there are switched off); 34 are in both. 47 of the 2024-only titles are derived from the package name.
- Planes in JoyPro:
engine db planes --game MSFSlistsMSFS(= all aircraft) and every key; the GUI's relation node plane picker shows them with title, category and sims.--node MSFS2024:<action>:<key>(MSFS2020:for 2020) (orrelations item add|enable|disable ... --node MSFS2024:<action>:<key>) limits a relation to aircraft. A node without aircraft or withMSFSactive is for all aircraft (unchanged for existing profiles). Auto Group and Auto Assign keep MSFS as one aircraft (MSFS, one input configuration for the whole game), because the export below cannot separate aircraft.
#Export of relations limited to aircraft
MSFS has per-aircraft input settings, but JoyPro cannot write them:
- MSFS 2020: one input profile per device (
inputprofile_*), used for every aircraft. [SRC docs above, OBS] - MSFS 2024: the sim keeps a record per device and aircraft in profile_00 with three preset slots (general /
category / aircraft), and the exe knows
General,CategoryAircraft,CommonAircraftandSpecificAircraftInputPresetForDevicepresets [OBS: profile_00 copy, FlightSimulator2024.exe strings]. JoyPro never writes profile_00 (checksum: a changed file made the sim discard the whole profile). Aircraft-specific default presets come only with the aircraft's own package: the SDK puts them in aninputsfolder besideattachments/common/liveries/presetsof the aircraft's SimObject (SimObjects\Airplanes\<aircraft>\inputs), and the exe allows input profile asset groups only underInputProfiles,SimObjectsorSimAttachments[SRC SDK "Aircraft Input Profile Package Setup", OBS exe]. Official aircraft are streamed, so JoyPro cannot add files to them. [INF, not tried] A Community package that overlaysSimObjects\<cat>\<aircraft>\inputsof another package might be picked up, but it was not tested in the sim and could also break the aircraft's SimObject; JoyPro does not do it. - So the export (both sims) writes one set of binds per device for every aircraft: the relations for all aircraft,
plus, with
engine msfs2024 export --aircraft <key>(GUI: Other Games > Export Aircraft), the relations limited to that aircraft. Without--aircrafta relation limited to aircraft is skipped with a warning that says why; an unknown key is reported. The 2024 preset then applies as before: to every aircraft the sim has not configured for that device yet. The game config watcher (engine sync) compares the game files with the relations for all aircraft (as the export without--aircraft). - Verified: the export rules on synthetic 2020 profiles (smoke test). Not verified in the sim: anything per aircraft
(no per-aircraft export exists to verify); the record names of
fs20-and Community aircraft in profile_00.
#Axis settings (model msfs, engine\AxisModels\Msfs.cs)
The game's Settings > Controls > device > Sensitivity page (one set per physical axis of the device and profile) and
the per-action options, in the file's units (the UI's percent; the UI code KeyCalibrationComponents.js/.html of the
2020 install has the ranges):
JoyPro key (binds tuning set --scope game:MSFS2024 --param ...) |
File | Range |
|---|---|---|
sensitivityPlus / sensitivityMinus (positive / negative half) |
AxisSensitivy / AxisSensitivyMinus |
-100..100 (UI slider -100..100 %; the SDK's "0..100" / "-100..0" is wrong: MS's own profiles have -50/-50) |
neutral |
AxisNeutral |
-100..100 |
axisDeadZone |
AxisDeadZone |
0..100 |
extremityDeadZone |
AxisOutDeadZone |
0..100 (the UI slider also allows negative values) |
reactivity |
AxisResponseRate |
-1 (off, default) or 100..2000 (the UI shows 0..100 %; the mapping is not known) |
noSensitivityCurve (0/1) |
Flag bit 1024 |
the action gets the raw axis |
axisOverride (0/1) |
Flag bit 4096 + <Axis .../> in <Action> before <Primary> |
the values for this action only (MSFS 2024) |
| Invert | Flag bit 128 |
- Import puts the values of the bound axis (the per-action
<Axis/>when flag 4096 is set, else the device's line) into the relation'sgame:MSFS2020/game:MSFS2024tuning; only values that differ from the defaults, so an untouched page leaves none. - Export writes only what the tuning sets: a key it does not have keeps the file's value (a relation without MSFS
values gets dead zone, extremity dead zone and sensitivity fitted from its base curve; neutral and reactivity stay).
Lines are edited in place (other attributes and lines keep their bytes); a version-1238 line (
AxisSensitivy,AxisDeadZoneonly) gets a missing attribute only when its value is not the default; a missing axis line is added in the sim's order (X, Y, Z, rX, rY, rZ, SliderX, SliderY) with the attributes the file's other lines use. - One page per device axis: relations on the same device axis share it. Different values are reported by
binds tuning setand by the export, which writes the first relation's values.axisOverride=1gives an action its own values (2024 profiles; in a 2020 profile the export warns and uses the device page). Without the key the export keeps the action's current override state and writes JoyPro's values where the game reads them for that action. - A released axis (or an action that becomes digital) loses flags 4/128/4096 and its per-action
<Axis/>(it used to stay behind); flag 1024 and the other bits stay unless the tuning setsnoSensitivityCurve. - The export warns when a changed device page also drives actions JoyPro does not manage (camera zoom etc.). Merge keeps a page changed in the game (not what JoyPro wrote or imported).
- Preview, measured in MSFS 2020 (2026-10-10,
tools\e2e\games\MsfsCurves.ps1: vJoy sweeps, SimConnect ELEVATOR POSITION / throttle lever; two runs with random pages, 84 points, max error 3e-4). With x the stick position and n = -neutral/100: the half x >= n uses Sensitivity -, the other half Sensitivity + (the sim works on the mirrored axis); a = |x - n|, h = the half's length (1 - n or 1 + n), d = dead zone/100: output 0 for a <= d, else v = (a - d)/(h - d) and y = (1 - e) * v(1+s)/(1-s+2sv) with s = sensitivity/100 clamped to +-0.99 (-100 = a step at the end of the travel) and e = extremity dead zone/100 (a cap on the output, not an early saturation). Flag 1024: the raw axis, but |x| <= d still gives 0 (not rescaled). Invert flips the result; THROTTLE_AXIS_SET_EX1 gets the value negated (full throttle at the stick's minimum). Reactivity is smoothing over time (not in the preview); its page slider shows (rate - 100)/19 %, -1 shows 100 %. - No force feedback: MSFS has none of its own (no DirectInput effects in either exe; FFB only through third-party
telemetry apps); assistance options (assisted yoke, auto-rudder) are not in the input profiles. No
FfbModelsentry.
Sources: https://docs.flightsimulator.com/msfs2024/html/5_Content_Configuration/Input/Input_Configuration_XML_Properties.htm, https://flightsimulator.zendesk.com/hc/en-us/articles/21862909046428, https://github.com/dmenne/FS2020Control, https://github.com/Z1ni/XGP-save-extractor.