Skip to content
SwisserAI LogoSwisserAI
Framework Converter HelpSwisserAI HelpOpen app

Convert

Reading the result

The result says in one line whether every check passed, lists what the checks found and shows every file before and after.

Passed or to review

A finished Framework Converter run opens on its result. The first box is the verdict:

  1. 1. Every check passed: or how many checks did not pass
  2. 2. Files, Syntax, Leftovers, Calls exist, Contract, Wiring: click one to filter the findings
  • Every check passed: the resource parses, has no leftover code, calls nothing that does not exist and keeps every name other resources use. The list shows it as Passed.
  • Delivered, but 2 checks did not pass: you can download and inspect it, but it is not finished. The list shows it as 2 to review. Read the findings before it goes near a live server.
  • The conversion failed: nothing to download. See Credits and failed runs.

Under the verdict, one line sums up the run, for example: files converted, repair rounds and names preserved.

The six checks

  • Files

    Every file survived at full length. Nothing was dropped or cut short.

  • Syntax

    Every Lua file parses, and every JSON locale is valid.

  • Leftovers

    No code of the source framework is left behind.

  • Calls exist

    Every framework call it makes exists in the target.

  • Contract

    Commands, events, exports, callbacks and items are unchanged.

  • Wiring

    The manifest and the files agree, and no new event points at nothing.

A check fails only on a blocker: something that stops the resource working. Warnings and notes are shown under the check name instead. Click a check to show only its findings; Showing one check. Show all brings the rest back.

  1. 1. Calls exist: click a check to filter
  2. 2. Showing one check. Show all: brings every finding back

What we found

The What We Found tab lists the findings, blockers first. Each one has a sentence in plain words, the precise detail, the check it belongs to and, where it applies, the file and line. Click the file name to open it in the diff.

  1. 1. What We Found: the findings of the six checks
  2. 2. Note: a finding with its check and detail
  3. 3. Every decision this conversion made: the plan, also in the report

Findings seen on real conversions:

  • 1 call relies on ecosystem convention rather than the core

    Note. The call is used by the framework’s own resources but not declared in the core. Valid in practice.

  • client/main.lua is not loaded by the manifest

    Warning. Often the original manifest never loaded that file either.

  • client/client.lua lost part of its content

    Blocker. The converted file is shorter than it should be.

  • The event "…" disappeared

    Blocker. A name other resources use is gone from the converted code.

  • client/main.lua still contains QBCore code

    Blocker. A call of the source framework survived.

Findings can also say the conversion carried over a defect the original already had. Those are shown so you do not blame the conversion for them.

Every decision this conversion made

Under the findings, Every decision this conversion made opens the plan: one line per construct that is not a plain rename, with the old call, the new one and why. For example:

xPlayer.removeMoney(amount) → Player.Functions.RemoveMoney('cash', amount, reason)
  check the returned boolean and do not grant the item when removal fails
ESX.UI.Menu.Open(...) → exports['qb-menu']:openMenu({ ... })
  install qb-menu

The files, before and after

The Files tab lists every file of the result. Pick one to see its diff: removed lines in red, added lines in green, unchanged stretches folded. The header counts added and removed lines.

  1. 1. File list: AS-IS marks files carried over unchanged
  2. 2. + added − removed: lines changed in this file
  3. 3. Diff / Result: the changes, or the whole new file
  • Diff and Result switch between the changes and the whole new file.
  • AS-IS next to a file means it was carried over unchanged.
  • Very large files show both versions in full instead of a line-by-line diff.

The rebuilt manifest in Result view, with the new dependencies at the bottom:

  1. 1. dependencies: the resources to start first
  2. 2. Result: back to Diff for the changes

The report in the zip

Every download holds CONVERSION_REPORT.md next to the resource files, so the caveats travel with the code. The start of the esx_shops report:

# esx_shops: esx → qbcore

Converted 8 files from ESX Legacy to QBCore. All checks passed after 1 repair round. 1/1 contract items preserved.

Converted by SwisserAI. 8 files, 1 repair round.

## Checks

- PASS **files**: 0 findings
- PASS **syntax**: 0 findings
- PASS **residue**: 0 findings
- PASS **api**: 1 finding
- PASS **contract**: 0 findings
- PASS **wiring**: 0 findings

### Worth knowing

- 1 call relies on ecosystem convention rather than the core

The report names the checks by short ids: residue is Leftovers and api is Calls exist. In full it contains:

  • The direction, the summary line and the number of repair rounds.
  • A PASS or FAIL line per check, the blockers in full and the other findings under Worth knowing.
  • What changed and why: the same decisions as on the result page.
  • Limits: what a static check cannot prove.
  • When a binary file could not be packed, Files you need to copy over yourself with their paths.

The report is not loaded by FiveM. Keep it with the resource, or delete it once you have read it.

Converting again

Each upload appears as a card under Your resources on the converter page, with its direction and status. Click it to open the result again, with the findings, the diff and the download.

  1. 1. esx_shops: opens the resource and its result
  2. 2. Passed / to review / Failed: the status of the last run

To convert the same resource to another framework, upload the zip again and pick the other target. The preview of each target is free, so you can compare them before paying for one.