Repository navigation
Releases
EmblemWeave 0.1.26
EmblemWeave 0.1.26
The upscaler hints and the README now name the folder the launcher and the engine actually read
Install
- Download EmblemWeave-v0.1.26-windows-x64.zip below and unzip it into a folder of its own.
- Run
EmblemWeave.exe. - On Game Setup, choose your dump. On Overview, press Build the game (once), then Play.
sha256 of the zip: c644e66f39ae995082618f020a29550ea27b7a5327f9e1f9bcaccd10fbfbcc6d
What changed
0.1.25 added the Upscaler files section to Graphics, but the hint under the Upscaling dropdown still sent players to
upscalers\fsr3 next to the game, and the README did the same. Neither is wrong (both folders are read), but it is not the
folder the new section names or the one the engine tries first.
- Every upscaler hint now says
upscalers\fsr,upscalers\streamlineorupscalers\xessin the play folder. - XeSS joined the Upscaling list and the DLSS replacement list in 0.1.25; the README now documents it, together with the extra
files DLSS Frame Generation and FSR 3 frame generation need. - The README describes Open the upscalers folder and Look for the files, and the F1 menu's
Files foundline they
answer.
Verified
cargo build --releaseandcargo test -p emblemweave: 119 passed, 0 failed.- A full engine build with the 0.1.23 compiler-flag change and the 0.1.24 build-folder reset:
build_fefw.ps1reached
[6/7] Linking CXX executable fefw.exeand exited 0. - Not checked: the hint text on screen (it is a string in the same row that was seen in 0.1.25), and a start with real AMD,
NVIDIA or Intel DLLs, which are not installed here.
EmblemWeave 0.1.25
EmblemWeave 0.1.25
The Graphics page now shows which upscaler files are on disk, where they go, and can find them for you
Install
- Download EmblemWeave-v0.1.25-windows-x64.zip below and unzip it into a folder of its own.
- Run
EmblemWeave.exe. - On Game Setup, choose your dump. On Overview, press Build the game (once), then Play.
sha256 of the zip: 2a56a670cb8aab53c7d67d15efca6fe5901156378d1cc1851e4b7e0e2612a564
Upscalers and frame generation (#26)
FSR 3.1, DLSS and XeSS all need DLLs their vendors do not let us ship. Without them the engine falls back to its own temporal upscaler
(TAAU) and frame generation does not start, which is what the F1 menu reported: Files found: DLSS no, DLSS-G no, FSR 3 upscaling no, ....
The exact folder to put them in was only in a tooltip, and the launcher did not look in the same places the engine does: upscalers\fsr
was searched by the engine and upscalers\fsr3 by the launcher, so following the old hint could change nothing.
Graphics has an Upscaler files section at the top:
- One row each for FSR 3.1, DLSS and XeSS, saying where the files were found or exactly which files are missing. FSR 3 frame generation is
named separately because it needs the v1.1.4amd_fidelityfx_vk.dll, which the v2.4 loader pair does not include; the same for DLSS
Frame Generation's five extra Streamline files. - Open the upscalers folder creates
%APPDATA%\EmblemWeave\play\upscalers\{fsr,streamline,xess}and opens it. - Look for the files searches the launcher's folder, the engine folder, Downloads and the Desktop one folder deep, copies what it finds
into that folder, and reports what is now ready and what is still missing. Running it twice copies nothing the second time. - The same search runs headless with
EmblemWeave.exe --adopt-upscalers, for a support report.
The launcher also looks in the engine folder and the run folder for both upscalers\fsr and upscalers\fsr3, which is where a copy made
into the package by hand now lands, and it passes [upscale] xess_dll as well as the FSR and DLSS paths to the game. XeSS is in the
Upscaling list and in the DLSS replacement list, so the engine's own XeSS support can be chosen from the launcher.
A build from an older release (#24, reported again on an old build)
The engine is compiled from the sources in your copy, so a new launcher beside an old build keeps running the old engine, which is how the
packed .nup crash from #24 came back in a report after it was fixed. The build now records [engine] built_by in fefw.ini, and
Overview says This game folder was built by an earlier release; press Rebuild to update its engine to 0.1.25 until it does.
Verified
cargo build --releaseandcargo test -p emblemweave: 119 passed, 0 failed.- The Upscaler files section was seen on the running launcher in both states: three missing rows with the folder path and the two
buttons, and three found rows after DLL-shaped files were placed in the run folder'supscalers(FSR 3.1 without frame generation,
DLSS with it, XeSS). --adopt-upscalerswas run against a fake Streamline set inDownloads\test-upscaler-sdk: it copied four files into
play\upscalers\streamlineand reportedfound: DLSS; missing: AMD's FidelityFX DLLs.- The Overview line was seen on the running launcher against a game folder with no
built_bystamp. - Not checked: real AMD, NVIDIA and Intel DLLs (none are installed here), and a game start that uses them.
EmblemWeave 0.1.24
EmblemWeave 0.1.24
A failed build now says so with the button that runs it again
Install
- Download EmblemWeave-v0.1.24-windows-x64.zip below and unzip it into a folder of its own.
- Run
EmblemWeave.exe. - On Game Setup, choose your dump. On Overview, press Build the game (once), then Play.
sha256 of the zip: 572ce517afa1e831ff0fd59135e95c8723241680088de2a490b9a319f4cd995b
Build again
A build that failed used to leave a message that faded after five seconds and nothing to press. The next step was always the same: press
Build the game again, which the build script now does safely on a folder a previous release left in the wrong state (0.1.23).
The failure message now carries Build again under it, and stays for a minute instead of five seconds. Pressing it drops the message
and starts the build, with the same progress in the status bar and Diagnostics. Every other message is unchanged: only a failed build
has an action attached.
Verified
cargo build --releaseandcargo test -p emblemweave: 119 passed, 0 failed.- Not checked: the message and its button seen on screen. A screenshot of the running launcher was taken while the build was still in
progress, and the window could not be brought in front of the other windows on this machine to catch the failure state. The button is
the same widget as the rest of the launcher's buttons, drawn inside the same message box.
Next
The build folder reset from 0.1.23 runs on its own, so Build again is a retry on a clean folder rather than a second attempt with the
same stale cache.
EmblemWeave 0.1.23
EmblemWeave 0.1.23
A build folder left behind by an older release no longer breaks the build with clang++'s "unknown argument"
Install
- Download EmblemWeave-v0.1.23-windows-x64.zip below and unzip it into a folder of its own.
- Run
EmblemWeave.exe. - On Game Setup, choose your dump. On Overview, press Build the game (once), then Play.
sha256 of the zip: 6ef5e7ca8479ae1beee868e711a721ca72e7f0c56ef6894ea45b64d41ab95bee
The error in #25
clang++: error: unknown argument: '-clang:-fmacro-prefix-map=…'
clang++: error: no such file or directory: '/W3'
Both lines are the same mistake: flags written for clang-cl reaching the clang++ driver. Two things made that possible.
The engine's own check for which driver is compiling was CMAKE_CXX_SIMULATE_ID STREQUAL "MSVC", which decides how the
-fmacro-prefix-map argument is spelled. On a Windows host that value is MSVC for the clang++ driver as well as for clang-cl,
so the check was true in both cases and the -clang: form went to clang++, which has no such argument. It goes by
CMAKE_CXX_COMPILER_FRONTEND_VARIANT now, which is only MSVC for clang-cl.
The other half is the build folder itself. A folder configured by an older release was configured for clang++, and CMake keeps the
flags it wrote for the first compiler when one is swapped in afterwards. The build script now reads the compiler a folder was
configured with before it configures anything, and starts the folder over when that is not the compiler it is about to use, so no
stale MSVC /W3 reaches a GNU driver.
Verified
- A fresh
clang++configure of the engine project now configures and compilesfefw_main.cppwith no argument error (-fmacro-prefix-map
as it is, no-clang:). - A build folder configured for
clang++and then built with the script prints that it is starting the folder over and builds
fefw_main.cppwithclang-cl(exit 0), which is the state the report was in. - The
clang-clrelease folder still configures and compiles that target after the change (exit 0). - Not checked: a full engine build from scratch on a machine other than this one, and the reporter's own machine. Their folder is
fixed by the script the first time they press Build the game on 0.1.23.
EmblemWeave 0.1.22
EmblemWeave 0.1.22
Play prepares a packed package and starts the game itself, so nobody has to know about the check first
Install
- Download EmblemWeave-v0.1.22-windows-x64.zip below and unzip it into a folder of its own.
- Run
EmblemWeave.exe. - On Game Setup, choose your dump. On Overview, press Build the game (once), then Play.
sha256 of the zip: ca5d0a0d1fa9f9660c197a19562ce910d3808ce303ce3507857ed1f422ad9b1d
Play does the check
A .nup that keeps some of its files packed with zstd cannot be read in place, and 0.1.21 put the repair behind a button on Game Setup.
That still asks the player to know which button to press, and a game folder built by an earlier release fails the moment they press Play
instead.
Play now does it on its own:
- If the built game points at a package whose files are packed and no overlay is recorded, Play starts the same check, keeps a note
that a game was asked for, and starts the game the moment the files are written. The status bar and Diagnostics show the writing. - Pressing Play again while that check is running does not write twice: it waits for the run already going and starts the game after it.
- If the check fails, the waiting game is dropped and the failure is shown, rather than a game starting from a half-written folder.
- A package that is read in place, and every ordinary dump, goes straight to the game as before.
Check my game folder on Game Setup stays, for anyone who wants to prepare the folder without starting the game.
Verified
cargo build --releaseandcargo test -p emblemweave: 119 passed, 0 failed.- Not checked: a press of Play on this machine against a packed package with no overlay, end to end. The check it starts is the one
measured on a real 28.9 GB.nupin 0.1.20 (65,074 files, 2.1 GB, engine booted from the package with the overlay), and the
condition that triggers it is the same one the engine logs as read.
EmblemWeave 0.1.21
EmblemWeave 0.1.21
Game Setup has a one-click check that prepares a packed package in a minute, without compiling anything
Install
- Download EmblemWeave-v0.1.21-windows-x64.zip below and unzip it into a folder of its own.
- Run
EmblemWeave.exe. - On Game Setup, choose your dump. On Overview, press Build the game (once), then Play.
sha256 of the zip: 458e40e76a36587eb3afbafb560e61a673119e0706d03d87d4ef00fab3869ab7
Game folder check
0.1.20 made the engine read a .nup that packs some of its files with zstd, by writing those files into work/romfs-overlay and
laying that folder over the package. The writing happened inside Build the game, which meant a player whose game was already built had
to sit through a full rebuild to pick it up.
Game Setup now has Check my game folder, above the validation list:
- It reads the package and reports how many files are packed and how large they are, or says the package is read where it lies when
there is nothing to write. - It writes those files into
engine\fefw-recomp\work\romfs-overlay, resuming where an interrupted run stopped, and does nothing if
they are already there. - It records the folder in
fefw.iniunder[fs] romfs_overlay, so the game that is already built starts using it: no compile, no
rebuild, and nothing about the package is modified. - If the game has not been built yet it says so and leaves the folder ready for the next build.
Verified
cargo build --releaseandcargo test -p emblemweave: 119 passed, 0 failed, including a test that the repair writes its key into
[fs]once and replaces it on a second run rather than adding another.- The Game Setup page shows the new section with its button, checked on a screenshot of the running launcher.
- The writing itself was measured on a real 28.9 GB
.nupin 0.1.20: 65,074 packed files, 2.1 GB, and the engine booted from that
package with the overlay. - Not checked: the button pressed with the mouse on a packed package end to end. The job it starts is the same writing path the build
uses, and the key it writes is the one the engine logs as read.
Still open
A package that packs its RomFS with a codec other than zstd still has to be repacked by hand; the launcher cannot read those.
EmblemWeave 0.1.20
EmblemWeave 0.1.20
A package that packs part of its RomFS with zstd now plays without being repacked, and its compressed files cost 2 GB instead of a second copy of the game
Install
- Download EmblemWeave-v0.1.20-windows-x64.zip below and unzip it into a folder of its own.
- Run
EmblemWeave.exe. - On Game Setup, choose your dump. On Overview, press Build the game (once), then Play.
sha256 of the zip: 13ef9f8edd5cea83e6c6a5ce7664fca477c3fd49fbdd42efaf5afeb31e37ce93
The crash two seconds after Play (#24)
A .nup can pack its files with zstd. A zstd entry is one frame for the whole file, with no way to seek into it, so the engine, which
serves the RomFS straight out of the package by offset, refused the package and the game broke on its first file:
fs: RomFS folder '...nup' cannot be served: main.npdm is compressed in the .nup
The refusal was the bug, in three places:
- A compressed ExeFS no longer stops anything. Those modules are loaded from the extracted
exefsfolder, so the package reader now
lists them and carries on. Before this, a package whose only packed files weremain.npdmandrtldwas rejected outright. - The packed RomFS files are written out, once, and laid over the package. The build writes exactly the entries that are packed (on the
dump measured here, 65,074 files, 2.1 GB, not the whole 20 GB RomFS) intoengine\fefw-recomp\work\romfs-overlay, and the engine reads
those through the new[fs] romfs_overlaykey. Everything else is still served from the package in place, so a packed game costs about
2 GB of disk rather than a second copy of the game. - The build says what it is doing and the play button explains a build from before this release. A game folder built by 0.1.19 still
points at the package with no overlay: Play now says to press Build once, instead of the game dying on a break two seconds in.
Verified
- The launcher wrote the overlay from a real 28.9 GB
.nup(65,074 packed files, 2.1 GB) with--unpack-romfs, and the engine then booted
that package withromfs_overlayset:RomFS: 65074 of 252686 files are packed with zstd and are read from [fs] romfs_overlay, the
overlay merged 65,074 files, and the game reached its autosave screen with no break and no crash. cargo build --releaseandcargo test -p emblemweave: 118 passed, 0 failed.- Not checked: a package whose RomFS is entirely packed, and a play-through past the first screen on one.
Still open
The one case that still needs a repack by hand is a package that packs its RomFS in a codec other than zstd, which the launcher cannot read.
EmblemWeave 0.1.19
EmblemWeave 0.1.19
New areas compile about four fifths fewer shader parts, the compilers step aside when the picture is late, and a fresh copy keeps everything in its own folder
Install
- Download EmblemWeave-v0.1.19-windows-x64.zip below and unzip it into a folder of its own.
- Run
EmblemWeave.exe. - On Game Setup, choose your dump. On Overview, press Build the game (once), then Play.
sha256 of the zip: e8b92e67c8b7092246038e93e119b3e969135d7a130a488e8d0a44ae9d5bc475
First-entry shader cost (#10)
- Shader parts are built when a draw asks for them. The engine used to compile the shader parts of every program the game set, before
any draw asked for them. In a measured session that built 2,975 parts and a draw took 341 of them: 88% of the work was for programs that
were set and never drawn with. A program's parts are now queued when a command buffer is recorded with it, a few frames before the draw
needs them. On the same route, part jobs per new program fell from 5.6 to 1.2 with the mean frame rate unchanged at 60. - The compile threads step aside when frames are late. A new area sets hundreds of programs at once and each part is a driver compile
that holds every core for tens of milliseconds, which is the processor peak that reads as the machine spiking. The background threads now
sleep for up to[nvn] compile_pace_ms(default 8) after a part once presented frames are past[nvn] compile_pace_after_ms(default 20),
so the frame in flight gets the cores back. Nothing is paced before the first frame, so the boot prewarm still runs flat out.
Portable, without anyone having to find a marker file (#21)
- A fresh copy keeps everything beside the program. On its first start, when there is no profile folder yet, the launcher puts
play,
work,saveandlogsintodatanext toEmblemWeave.exe. Unzip it anywhere, carry it on a stick, and the saves and the build
cache travel with it; no other copy on the PC sees them. - A copy already using the profile can switch from the launcher. About now has a Storage section that names the folder in use, whether
it is portable, and a button that turns it on: it writes the marker, createsdataand copies your saves across. Restart to finish; the
game is built into the new folder on the next build. Nothing is deleted from the old folders. - Deleting
portable.txtgoes back to%APPDATA%\EmblemWeave.
Verified
cargo build --releaseandcargo test -p emblemweave: 118 passed, 0 failed, including the new switch test.- A copy started with an empty profile folder wrote
portable.txtand itsdatafolder on its own, and the About page showed the new
Storage section with the folder it was using. - The two shader runs above were 100 seconds of the same scripted route on this PC. The GPU driver's own shader cache was warm for both, so
the counts of part builds are the measurement; wall-clock milliseconds of compilation were not compared. - The 32 ms worst frame in the demand-driven run (against 21 ms) is the cost of a part being built closer to its first draw; the runs also
diverged, with the new default reaching 300 bound programs against 157.
Still open
Native Linux and Steam Deck support (#7) is a port. The save-file browser and the per-game controller vibration of #10 are separate work.
EmblemWeave 0.1.18
EmblemWeave 0.1.18
The build survives spaced and apostrophe folders, the pipeline stops opening hundreds of console windows, and the launcher finally has a portable mode
Install
- Download EmblemWeave-v0.1.18-windows-x64.zip below and unzip it into a folder of its own.
- Run
EmblemWeave.exe. - On Game Setup, choose your dump. On Overview, press Build the game (once), then Play.
sha256 of the zip: 56f68b43d20207cd0e26012cdffbacd59dd69b785c0778a2a413b1e4fd000e61
This release is the answer to the reports filed against 0.1.17. Every build failure in them has one of two causes, both
fixed here, and the two other defects the reports found are fixed as well.
Build errors (#19, #22, #16, #18, #17, #11, #6, #3)
- A cache wipe turned Release into Debug. 0.1.17 set
CMAKE_RC_COMPILERafterproject(). CMake then announced
that its cache had to be deleted, configured again with its defaults, and the second pass picked theclang++driver
in Debug instead of theclang-cldriver in Release. The first compiler call after that failed with
clang++: error: unknown argument: '-clang:-fmacro-prefix-map=…', and every report in the list above ends with that
line. The resource compiler is now chosen beforeproject(), the macro-prefix-map flag is chosen by driver, and
build_fefw.ps1namesclang-clandllvm-rcby full path in the first configure so nothing changes after the cache
is written. - Spaces and apostrophes are not a problem, and never were the reason for the errors. A build from a folder with
spaces in its name was run for this release: it configuredclang-cl, Release,llvm-rc, compiledfefw_objand
linkedfefw.exe. The shader translator is built from a staged copy rather than from the game's own folder, so an
apostrophe in "Fortune's Weave" cannot reach MSBuild's path handling, which was the "cannot be created" error of
0.1.16 and earlier. Non-ASCII folders work for the same reason, though an older release still fails in them. - Decoding no longer picks the Microsoft Store alias. The launcher ran whatever
pythonresolved to. On a PC without
a real install that is the Store alias, which prints no version and opens the Store, and the decode stage reported
only "the bridge reported an error" (#11). The launcher now asks each candidate for--versionand uses the engine's
own virtual environment first, thenpy -3, thenpython.
The pipeline's wall of console windows (#23)
The compile stage starts one C compiler per shard. The launcher is a GUI program, so every compiler it started without
CREATE_NO_WINDOW opened a console of its own, and a large module is hundreds of shards: that is the thousands of blank
windows, and why they went away with the launcher. Every child the pipeline starts now sets the flag and inherits no
window. They were compiler processes throughout, not a shell, and the project contains no PHP at all; the troubleshooting
page now says that in as many words.
Portable mode (#21)
An empty portable.txt beside EmblemWeave.exe moves data, cache, logs, play and work into a
data folder next to the program, so a release lives on one USB stick. Without the marker nothing changes. The
About page shows which of the two is in use.
Smaller repairs
apply_patch.pycreates the directories a patch writes into and exits cleanly when a patch is already applied, which
is what made the shader step fail on a second run.control.nacpis read as text rather than as a version number, so a dump whose package has it is not rejected.- The
zstderror no longer names a cache folder that does not exist. - The haptics DLL is put beside
fefw.exebefore a launch, not only after a build, so updating the launcher does not
drop rumble to the standard two motors (#10).
Verified
cargo build --releaseandcargo test -p emblemweave: 117 passed, 0 failed.- Engine configure and build from a path containing spaces:
CMAKE_BUILD_TYPERelease,clang-cl,llvm-rc, no
"cache to be deleted" line,fefw_objcompiled,fefw.exelinked. - The window flag is set on every spawn in
jobs.rs; a full pipeline run was not watched for windows in this release.
Still open
Native Linux and Steam Deck support (#7) is a port, not a repair, and stays requested. The save-file browser, the shader
compile cost on first entry to a new area, and per-game controller vibration are tracked in #10 and are the next work
rather than part of this release.
EmblemWeave 0.1.17
EmblemWeave 0.1.17
The engine is Obersteinn's preserved 0.2.0 tree, it builds from an empty folder on this PC, and the game was played to the menu and back to check it
Install
- Download EmblemWeave-v0.1.17-windows-x64.zip below and unzip it into a folder of its own.
- Run
EmblemWeave.exe. - On Game Setup, choose your dump. On Overview, press Build the game (once), then Play.
sha256 of the zip: 6be61f323a18500d8d7281b9d93c07a9f600763cb3e27c8b654af1d5cd85efb4
What's new
- The engine is the tree Obersteinn preserved, not an older one.
engine/fefw-recompwas replaced wholesale with the
0.2.0 tree: haptics through the vendoredrenHDrum.dll, ASTC transcoding on the GPU, residency management, the Vulkan
layer filter, the render status page, the per-CPU game variants and the per-block shader journal the build keeps. 0.1.16
ran an earlier engine, and docs/UPSTREAM.md now says plainly that the audit behind it compared
build tools rather than runtimes, which is how a tree that was not the final one passed. - The Windows resource step no longer hangs. On this PC the SDK's
rc.exesat at zero CPU on the preprocessed
fefw.rcfor fifteen minutes, having written its temp files and never returned, and the build stopped at 147 of 150
targets.game-build/fefw/CMakeLists.txtnow gives the job tollvm-rc, the resource compiler that ships beside the
clang-clthis build already requires, and replaces a cache that still namesrc.exe. The same file compiles in
milliseconds. - A failed build names the failure, not a warning above it.
env.cmdprobes for Visual Studio throughvswhere, and
when that probe misses it prints'vswhere.exe' is not recognizedand carries on with the toolchain already onPATH.
The launcher searched the whole log for a missing program, found that line, and told the player to installvswhere
when the build had in fact died at the resource step. It now looks at the reason the step gave first, and only then at
the wider log.
Verified by building and playing it
The build was run from an empty build folder on this PC, and then the game was played:
prepare_exefs.pycopied the ExeFS out of the dump;build_game.cmd fefwlifted and compiled the six libraries
(89 710 functions, 6 715 398 instructions, none left untranslated);build_fefw.ps1configured withclang-cland
llvm-rcand built 585 of 585 targets intofefw.exe; the corpus was extracted from the RomFS and all 12 088 shader
blocks are translated, with the 79 blocks beyond the translator listed inresults.tsv; the launcher wrote
%APPDATA%\EmblemWeave\play\fefw.ini.- The game then ran from that folder: the title screen at 60 fps, Continue loading the save in use (Part I,
Theodora's Path, chapter 4, Unlikely Alliances, Dagson), the hub area rendered with its minimap and objective line,
the character walking forward whenWwas held, Tab opening the in-game menu, and F1 opening the engine's
settings overlay. 47 to 68 fps through the visit, texture uploads and ASTC transcodes settling as areas loaded, and no
errors infefw.log. - The keyboard needs a held key on this engine. The menu moves on
1234(the D-pad), not the arrow keys, which
drive the right stick; a key pressed and released inside one frame is not seen at all, which is why a quick synthetic
tap did nothing at the title screen.
Under the hood
- The build copies
renhdrum.dllbesidefefw.exeafter linking, the only folderhaptic.cpploads it from, so rumble
arrives through the game's own haptic calls instead of the standard two-motor fallback. - The Controls page writes
[pad] hapticand[pad] haptic_strength, the keys this engine reads, and still reads the
olderrumbleandrumble_scalefrom files written before them. - The shader step calls the harness without
--only-missing: this tree keeps a per-block journal and resumes from it, so
the flag the previous tree needed is gone. - Eight JSON files this tree needs to build are in the repository even though its
.gitignoreexcludes*.json, among
themdump_hashes.jsonand the two test oracles.