Vix.cpp v2.6.1

Vix.cpp v2.6.1 is a patch release focused on diagnostics, SDK release validation, and post-v2.6.0 stabilization.

Vix.cpp v2.6.0 was a large release. It introduced major workflow and runtime foundations such as AI agent support, official vix.app support, Vue + Vix workflows, target-aware builds, async-powered development sessions, and the first serious game runtime foundation.

v2.6.1 is the follow-up release that hardens that foundation.

The focus is not new surface area.

The focus is making failures clearer, release packages safer, and SDK consumption more trustworthy.

Release focus

The main focus of Vix.cpp v2.6.1 is reliability after a large release.

Large releases often expose problems that only appear when the full SDK is packaged, installed, linked, and used as a consumer would use it.

v2.6.1 improves that part of the release process.

It strengthens:

  • runtime diagnostic formatting
  • build diagnostic location selection
  • test failure output
  • vix dev failure reporting
  • SDK package validation
  • installed header checks
  • static library checks
  • CMake package file checks
  • exported target validation
  • full SDK consumer linking through vix::vix

The release makes Vix.cpp better at answering one important question:

If something fails, can the developer quickly understand what failed and why?

Clearer runtime diagnostics

Vix.cpp v2.6.1 improves runtime diagnostic formatting for clearer CLI output.

Runtime failures should not feel like raw noise. They should point the developer toward the useful part of the failure.

This release improves diagnostics for bad variant access errors and generic runtime failures.

When runtime logs contain useful information, Vix now extracts that information and presents it more clearly.

The goal is to reduce the distance between the failure and the fix.

Instead of forcing developers to scan long logs manually, Vix tries to show:

what failed
where it failed
why it likely failed
what context matters

vix dev now uses the same diagnostic pipeline

vix dev runtime failures now route through the same diagnostic pipeline used by vix run.

This matters because development mode should not have weaker error reporting than manual run mode.

Before this change, the same runtime problem could be easier to understand through vix run than through vix dev.

v2.6.1 makes the behavior more consistent.

If an application fails while running inside the development session, Vix can now present the failure through the same diagnostic model used elsewhere in the CLI.

This is part of the larger direction of Vix.cpp:

same project
same runtime
same diagnostics
same developer workflow

Less duplicated runtime output

v2.6.1 reduces duplicated runtime log output when a clear diagnostic is already available.

This is important because a diagnostic tool should not make failures harder to read by printing the same information several times.

When Vix can produce a focused diagnostic, the surrounding logs should support that diagnostic, not bury it.

This makes runtime failure output more compact and easier to scan.

Better build diagnostic locations

Vix.cpp v2.6.1 improves build diagnostic location selection.

When possible, Vix now prefers user code over system headers.

This fixes misleading build diagnostics that pointed to standard library headers instead of the project files that caused the error.

This is especially important in C++.

A mistake in user code can often appear deep inside:

standard library headers
template internals
system headers
third-party headers

But the useful location is usually the project file where the template, type, or API was instantiated incorrectly.

v2.6.1 improves that selection so diagnostics are more helpful.

The goal is not to hide compiler output.

The goal is to anchor the diagnostic closer to the code the developer can actually change.

Cleaner CTest assertion failures

vix tests receives better output for failed C and C++ assertions.

CTest assertion failures are now rendered as clean Vix diagnostics.

When an assertion fails, Vix can show:

  • the failing source location
  • the assertion message
  • a compact code frame

This improves the test debugging loop.

Instead of reading a raw test runner block and manually searching for the relevant source line, the developer gets a focused diagnostic.

This is important because Vix.cpp is adding more tests across modules, runtime behavior, CLI workflows, and SDK validation.

As test coverage grows, test failure output must stay readable.

Missing runtime resources

v2.6.1 adds clearer diagnostics for missing runtime resources.

Missing resources can happen when:

  • an application expects a file that was not copied
  • a packaged SDK is incomplete
  • a generated project references a missing asset
  • a runtime path is incorrect
  • an installation step did not produce the expected output

The improved diagnostics help distinguish a missing runtime resource from a generic runtime failure.

This makes configuration and packaging problems easier to understand.

Stronger SDK release workflow

One of the most important areas in v2.6.1 is SDK release validation.

The release workflow was strengthened to validate a complete and faithful Vix SDK package.

This matters because Vix is not only built from source.

Users also need to install and consume packaged SDK releases.

A release package must contain the pieces a real C++ application needs:

  • installed headers
  • static libraries
  • CMake package files
  • exported Vix targets
  • complete module symbols
  • usable consumer targets

v2.6.1 adds stricter SDK release checks for all of these areas.

The release process now does more than produce an archive.

It validates that the archive is actually usable.

Validating vix::vix as the single consumer target

v2.6.1 improves SDK release validation to ensure that:

vix::vix

can be used as the single consumer target for full SDK projects.

That is important for user experience.

A consumer should be able to write:

find_package(Vix CONFIG REQUIRED)

target_link_libraries(app PRIVATE vix::vix)

and get a working full SDK integration.

This release improves validation so packaged releases test real linking through that path.

That means SDK validation is closer to how real users consume Vix.

Catching missing module libraries

v2.6.1 fixes incomplete SDK release validation that allowed missing module libraries to pass CI.

This is a critical release-quality improvement.

A package can appear valid if the build succeeds, but still be incomplete if some module libraries are missing from the installed SDK.

The release validation now checks more faithfully that the SDK package includes the expected libraries and exported targets.

This helps prevent broken packages from being published as valid releases.

WebSocket symbol validation

v2.6.1 fixes SDK packaging checks so missing WebSocket symbols are caught.

The release specifically improves validation around symbols such as:

LowLevelServer::run
Session::shutdown_now
LongPollingManager::push_to

These symbols matter because missing exported symbols can break real consumers even when the source repository builds correctly.

The packaged SDK must not only compile internally.

It must link externally.

v2.6.1 improves that external-consumer confidence.

Internal module reference updates

This release also updates internal module references for the v2.6.1 patch release.

This keeps module versioning and internal references aligned after the v2.6.0 release.

Patch releases often include this kind of maintenance work to ensure the repository, modules, and SDK package all agree on the current release state.

Issues discovered after v2.6.0

v2.6.1 fixes issues discovered after the v2.6.0 release.

This is normal after a large release.

v2.6.0 introduced significant new workflows and infrastructure. v2.6.1 follows by tightening the parts where packaging, diagnostics, and real consumer usage needed stronger validation.

The result is a more trustworthy v2.6 line.

Highlights

  • Updated internal module references for the v2.6.1 patch release.

  • Improved runtime diagnostic formatting for clearer CLI output.

  • Improved CLI runtime diagnostics for bad variant access errors.

  • Added clearer diagnostics for missing runtime resources.

  • Improved generic runtime failure handling by extracting useful error information from runtime logs.

  • Routed vix dev runtime failures through the same diagnostic pipeline used by vix run.

  • Reduced duplicated runtime log output when a clear diagnostic is already available.

  • Improved build diagnostic location selection to prefer user code over system headers.

  • Fixed misleading build diagnostics that pointed to standard library headers instead of project files.

  • Improved test failure output to render CTest assertion failures as clean Vix diagnostics.

  • Fixed vix tests output for failed C/C++ assertions by showing the failing source location, assertion message, and code frame.

  • Strengthened the SDK release workflow to validate a complete and faithful Vix SDK package.

  • Added stricter SDK release checks for installed headers, static libraries, CMake package files, and exported Vix targets.

  • Improved SDK release validation to ensure vix::vix can be used as the single consumer target for full SDK projects.

  • Fixed incomplete SDK release validation that allowed missing module libraries to pass CI.

  • Fixed SDK packaging checks to catch missing WebSocket symbols such as LowLevelServer::run, Session::shutdown_now, and LongPollingManager::push_to.

  • Fixed SDK consumer validation so packaged releases test real linking through find_package(Vix CONFIG REQUIRED) and target_link_libraries(app PRIVATE vix::vix).

  • Fixed issues discovered after the v2.6.0 release.

Compatibility

Vix.cpp v2.6.1 does not introduce intentional breaking changes.

Existing v2.6.0 workflows continue to work:

vix build
vix run
vix dev
vix tests

The main changes are improvements to diagnostics and release validation.

For SDK consumers, the important path is:

find_package(Vix CONFIG REQUIRED)

target_link_libraries(app PRIVATE vix::vix)

v2.6.1 improves release validation so this consumer path is tested more faithfully before an SDK package is accepted.

For CLI users, runtime and test failures should now be easier to understand.

Notes

Vix.cpp v2.6.1 is a small but important patch release.

It improves the experience around failures.

It also makes the SDK release workflow more serious.

That matters because a native C++ application platform cannot only work inside its own repository. It must also work when packaged, installed, found through CMake, linked into a consumer application, and executed through the CLI.

v2.6.1 strengthens that path.

The direction is clear:

better diagnostics
stronger SDK validation
cleaner test output
more reliable release packages

This release makes the v2.6 series safer after the major v2.6.0 expansion.