Skip to content

Kiss(met) s(tring) E(ditor)

Rewrite the text a game hardcoded inside its own code.

Plenty of a game's text lives in blueprint bytecode, not in any locres file. KissE finds those strings, swaps the instruction itself, and repairs the offsets so the game still runs.

One string, before and after
offsetinstructionvalue
0x100EX_StringConstBouger curseur
0x100EX_StringConstaaaaaaa1111
EX_Jump→ 0x108

0x500EX_UnicodeStringConstMove cursor
EX_Jump→ 0x108

Every place a game can hide a piece of text

EX_StringConst EX_UnicodeStringConst StrProperty TextProperty DataTable StringTable LocalizedSource ScriptBytecode

The strings no locres file contains

Games keep text in two different places. One of them is the localization data every archive tool can read. The other is code, and it only opens up if you are willing to edit the instruction.

Two kinds of work behind one tool

A tooltip, a debug label, a Set Text node. The string sits in the script as an instruction operand, so no locres export will ever show it and no CSV can translate it.

  • EX_StringConstscript operandjump and offsets
  • LocalizedSourcestring const inside a text constjump and offsets
  • TextPropertyrich text, with some riskvalue swap
  • StrPropertyasset propertyvalue swap
  • StringTablenamespaced keysvalue swap
  • DataTablerowsvalue swap

Reads a .pak without unpacking it

A virtual provider mounts the archive in memory and pulls the .uasset and .umap files straight out of it. Nothing lands on disk. Encrypted archives work too, pass the key with --aes.

Every function, not just the graph

Strings hide outside ExecuteUbergraph too, in widget event handlers and plain UFunctions. --patch-all-functions walks the whole ScriptBytecode instead of stopping at the graph.

Packs, then launches the game

--pack-folder writes the edited assets into a prepared folder. --run hands that folder to UnrealPak and starts the game after, so you see the result immediately instead of clicking through by hand.

The bytecode swap, instruction by instruction

Kismet bytecode is a flat list of instructions, and there is no room to grow a string in place. So the original spot gets a filler of exactly the right length, and the real string goes to the end of the script with a jump back.

BP_EnigmeCemetery.uasset, ScriptBytecode
Before
0x100EX_StringConstBouger curseur

The instruction being replaced. KissE measures the whole thing first, sub-instructions included, because that total size is what has to be preserved.

0x108next instruction

The instruction that used to follow. It is not moved, and it is where execution has to end up again once the string has been read.

After
0x100EX_StringConstaaaaaaa1111

The filler that takes the original's place. Seven a characters, then ones, so it is easy to spot in a hex dump. Nobody ever reads it: its length is the payload, and that length is the measured size minus 7, which is the 2 bytes of the ConstString opcode plus the 5 bytes of the jump that follows it.

EX_Jump→ end of script

Jumps over everything that was appended, so the filler is read and then control carries on past the relocated string.

0x108next instruction

Same offset, same instruction, untouched. The jump back lands here, so from the game's point of view nothing about this part of the script changed.

endEX_UnicodeStringConstMove cursor

The original statement itself, converted to the Unicode form and moved to the end of the script, where there is room for a string of any length.

EX_Jump→ 0x108

Jumps back to where execution came from, right after the filler.

200519
The outward jump is written as this placeholder first, spelled To End Script in the source, and replaced with a real byte offset once the layout is known.
60519
The return jump gets its own placeholder, spelled From End Script, resolved the same way in the same pass.

This is the Kismet bytecode path only. It applies to EX_StringConst inside ScriptBytecode, and to LocalizedSource, which is a string const nested in a text const. The other four types, TextProperty, StrProperty, StringTable and DataTable, are a plain value swap with no jumps and no offset arithmetic, which is why they are marked as such in the list above.

Why not simply write a longer string

Because the operand has a fixed size on disk. Growing it in place would shift every instruction after it and corrupt the function, and a translation is almost never the same length as the string it replaces.

What the two numbers are for

Every offset stored inside a moved statement has to be corrected, and there are four kinds of them in Unreal bytecode: CodeOffset, EndGotoOffset, NextOffset and PushingAddress. Offsets before the replaced string shift by the relocation, offsets after it shift by the relocation plus the size difference.

Command shapes

The CLI runs in two directions. Extract turns an asset into JSON, replace turns that JSON back into an asset. Everything else is a flag on one of those two.

Extract from a file or a folder
kisse.exe "A:\Games\Wigmund\BP_EnigmeCemetery.uasset" "A:\out\UI_Tooltip.json" -sc -paf
asset BP_EnigmeCemetery.uasset ScriptBytecode found
version 5.1 from the .usmap next to the exe walk 214 UFunction with bytecode
found 37 EX_StringConst ok
found 12 StrProperty ok wrote A:\out\UI_Tooltip.json 49 entries

Two things to have ready

A plain .uasset on disk needs neither of these. A .pak from a shipped game usually needs the first, and assets that were compiled without type information need the second.

Encrypted .pak

The AES key, if there is one

  • --aes=0x...
  • The virtual provider cannot mount an encrypted archive at all without the key, so this one is not optional in that case.
  • It is 32 bytes written as 64 hex characters. A 0x in front is accepted and ignored.
  • Games that ship their keys publish them. If the archive is not encrypted, leave this out.
Unversioned assets

The .usmap, usually

  • --mapping-auto
  • --version=5.1
  • A .usmap tells UAssetAPI what each property type actually is. Without it the asset still opens, but the types are guessed.
  • Assets also lose their virtual folder, and that folder is what --pack-folder uses to build the output path.
  • Drop a .usmap next to the executable and --mapping-auto picks it up, or point at one with --mapping.
  • No usmap to hand? The usmap also carries the engine version, so --version covers the rest.

Asset in, translated code out

The same four moves every time. Only the middle one is new work, and that is the part that needs you.

Drop the asset

Drag a .uasset, a .umap or a whole .pak onto KissE, or pass the path as the first argument. A folder works too, and a .pak is read in place without unpacking it first.

Get the JSON

Every string it found lands in one UberJSON file, original next to the empty field you are about to fill.

Fill in the new value

Edit the JSON in any editor, or let the built-in translation pass do it through Yandex, Google, Microsoft or OpenRouter.

Write it back

Point KissE at the JSON and it rewrites the bytecode, corrects the offsets and leaves a .bak next to the original.

KissE and UEExtractor

Two tools, two different layers of the same game. They overlap in places, and neither one replaces the other.

UEExtractorarchive level

Gathers the strings out of every asset

Opens .pak and .utoc archives, then walks the assets inside them and pulls every localization string it can find into one CSV. Reading a compiled .locres is one path of several, not the whole job.

  • DataTable, StringTable, TextProperty and StrProperty, collected asset by asset
  • Works for games that never shipped a .locres file at all
  • Works when the .locres exists but is stale, or is missing entries
  • Reads a current .locres directly, and patch mode keeps the original key order
  • AES keys, .usmap mapping files, and game auto-detection

UEExtractor

KissEasset level

Edits the code itself

Opens .uasset and .umap files, straight out of a .pak if you point it at one, finds the strings hardcoded in the script, and rewrites the instruction so your text replaces them.

  • EX_StringConst replaced with EX_UnicodeStringConst
  • Offset correction and the jump back, so the game keeps running
  • Every UFunction with bytecode, not only the ubergraph
  • Packs the result and launches the game to check it

The one thing it does that the other cannot: bytecode is the only string source that has to be rewritten as code, and KissE is the only tool here that does it.

Where the two overlap

  • DataTable
  • StringTable
  • TextProperty
  • StrProperty
  • UberJSON
  • .usmap
  • OpenRouter
  • Ollama
  • .bak
  • namespace
UEExtractor collects everything the assets hold as localization, even when no .locres was ever shipped or the one that exists is stale.
KissE takes what the blueprints hardcode as code, which never appears in an asset as a plain string.
Together you translate both halves and the game speaks your language everywhere, not just where the developers prepared a table.

Every argument

Twenty nine of them, taken from the command line parser in the source rather than the readme, which documents fewer. Filter by flag name, or by what you are trying to get done.

What to extract6

--sconst-sc

Extracts and packs EX_StringConst from every UFunction with a ScriptBytecode. This is the main one, and the one to reach for when strings are missing.

--tprop-tp

Fallback type for strings held in a TextProperty.

--lsource-ls

Fallback type for LocalizedSource. These sit inside a text const, so they take the bytecode path and the offset work that comes with it.

--dstable-dst

Fallback type for DataTable and StringTable assets.

--alltypes-all

Every type above at once, tables and LocalizedSource and TextProperty included. The easy way to see all an asset holds.

--namespace-ns

Puts the name in the output as key::value, for example ENG::Gori. Useful when two assets share string names.

What to change4

--patch-all-functions-paf

Runs the bytecode replacement over every UFunction with a Script, not just the ExecuteUbergraph_* ones. Needed for widget event handlers and other functions that hold their strings outside the graph.

--patch-assignments-pa

Also replaces EX_StringConst inside an AssignmentExpression in the ubergraph. Off by default so technical paths and keys are left alone. Opt in for text hardcoded through Set Text or Print String nodes.

--only-key-tok

Keeps only the table entries whose column name matches, for example -tok=ENG.

--debug-d

Writes Ubergraph.json next to the result. That is the whole graph, and it is how you find out why a string was not picked up.

Where the files are5

--virtual-vir

Switches the provider to virtual mode and reads assets out of the archive in memory instead of looking for them on disk. A .pak path is handled this way automatically.

--aes-a

32 character hex key, 64 hex characters, for an encrypted archive. 0x in front is fine. The virtual provider needs it to mount the pak at all.

--mapping-map

Uses the .usmap you point at, for example -map="Gori_umap.usmap".

--mapping-auto-ma

Picks up the .usmap on its own when it finds one nearby.

--all-directories-alldir

Drops the filter that skips known directory names during analysis and asset processing. Slower, and it reaches assets that are normally left alone.

Output and automation7

--pack-folder-pf

Writes the result into a folder prepared for it, keeping the virtual path, for example "ManicMiners_RUS". Writing back into a .pak is not possible, so a pak input always ends up here.

--run-r

Runs a command in the terminal once the work is done, for example --run=[CommandArgs]. Chain UnrealPak and the game itself, separated by a pipe.

--uexp-xp

Includes .uexp files in the analysis and in processing.

--version-v

Engine version used for correct processing, for example -v=5.1. Usually the mapping file already tells it.

--no-backup-nobak

Skips the .bak files. Faster on big folders, and one step closer to not being able to undo a mistake.

--no-filter-nf

Turns off the string filter while processing, so nothing gets dropped as looking like an identifier.

--no-underscore-un

Drops strings that contain the underscore character, such as ex_string.

Translation and reference7

--translate-tr

Turns on automatic translation of the extracted strings through the service you pick with the flags below.

--endpoint-e

Translation service to use, for example -e=yandex. router goes through OpenRouter, and google and microsoft are there too.

--api-key-api

Key for the OpenRouter API, for example --api-key=sk-or-v1-....

--api-Model-model

Model to translate with, for example tngtech/deepseek-r1t2-chimera:free.

--source-lang-sl

Source language for the translation, for example --sl=en.

--target-lang-tl

Target language for the translation, for example --tl=ru.

--help-h

Prints the built in reference.

Nothing matches that. Clear the field to see all of them again.

Idea, research, and the tool itself

KissE started as an idea about what was sitting inside blueprint bytecode, and it grew out of the research that came with it. The tool you can download today was written from scratch in C#.

  • DenisSolicen Author and maintainer. Wrote KissE from scratch in C#, and ships every release from the first 1.0.0 onward, handling the pull requests and the issues on his own.
  • Ambi The original idea, and the research behind it. Co-author of the project and co-holder of the copyright.
  • @atenfyr Research, and the UAssetAPI library KissE reads Unreal Engine files and bytecode with.

Put your text in the code.

Download a release, drop a .uasset, a .umap or a .pak on the executable, and the JSON is yours to fill in.

Language
C#
Input
.uasset / .umap / .pak
Licence
MIT
Stars
10 on GitHubна GitHub
DownloadСкачать Source codeИсходный код Latest releaseПоследний релиз v1.0.5.7