Vix.cpp v2.5.2

Vix.cpp v2.5.2 is a developer experience and runtime execution release. This release introduces a stable options-based vix::print(...) API, a simple vix::input(...) API, modular runtime and template diagnostics, single-file binary export, runtime target execution, direct binary execution, smarter vix run target resolution, and optional HTTPS support in vix::core. The focus of this release is clarity. Vix.cpp improves how developers write small programs, run different target types, diagnose advanced C++ errors, and configure HTTP or HTTPS server execution.

Stable print and input APIs

Vix.cpp v2.5.2 adds a stable options-based print API. The new API supports Python-like print customization through:

vix::print(vix::options{...}, ...);

The existing print API remains compatible. This release also adds a simple interactive input API for console applications:

vix::input(...);

Dedicated examples were added for both print_v2 and input. These APIs matter because Vix is not only a backend runtime. It also aims to make native C++ application development more ergonomic for small programs, scripts, examples, and teaching workflows.

Runtime diagnostics

Vix.cpp v2.5.2 adds modular runtime error rules in the CLI. The new runtime diagnostics cover common C++ execution failures such as joinable thread destruction, data races, deadlocks, mutex misuse, condition variable misuse, future and promise misuse, thread creation failures, detached thread lifetime issues, invalid container access, iterator misuse, dangling std::string_view, and dangling std::span. Runtime error prioritization was also improved so specialized concurrency diagnostics are shown before generic uncaught exception messages. This gives Vix a clearer diagnostic pipeline for real C++ runtime failures, especially the kinds of errors that are common in concurrent and systems-level code.

Template and coroutine diagnostics

Vix.cpp v2.5.2 adds modular template error rules for clearer compile-time diagnostics. The release includes dedicated handling for missing typename before dependent types, missing nested types or type aliases, template argument mismatches, substitution failures, requires-expression failures, concept constraint failures, constrained overload failures, lambda capture lifetime issues, coroutine return type errors, missing co_return, invalid awaitable usage, invalid coroutine promise_type, and missing await_ready, await_suspend, or await_resume. It also improves diagnostics for deleting through a base class with a non-virtual destructor, object slicing, invalid override, and invalid downcasts. This is especially important for advanced C++ users because template, concepts, coroutine, and inheritance errors often produce long compiler traces. Vix does not hide the compiler. It adds a focused diagnostic layer that helps developers reach the actual cause faster.

Single-file binary export

Vix.cpp v2.5.2 adds single-file binary export in vix build. Developers can now produce executables directly from single-file programs using:

vix build main.cpp --bin --out app

Cross-compilation support for single-file builds was also added through:

vix build main.cpp --target <target>

This makes vix build more useful for small utilities, examples, experiments, and distributable single-file C++ programs. The command reuses the script execution engine from vix run, which keeps build and run behavior consistent.

Runtime targets in vix run

Vix.cpp v2.5.2 expands vix run beyond local scripts and projects. The command now supports runtime targets such as:

vix run docker://nginx -p 8080:80
vix run container://nginx -p 8080:80
vix run ssh://user@host
vix run https://example.com

docker://image and container://image execute containers through Docker. ssh://user@host executes remote commands through SSH. http:// and https:// targets fetch URLs through curl. Runtime arguments after the target are now forwarded directly to the runtime. This removes the need for --run when using runtime targets. Vix also adds direct binary execution:

vix run ./app

This release introduces smart target resolution so vix run can automatically resolve between scripts, binaries, projects, and runtime targets.

Interactive execution improvements

Vix.cpp v2.5.2 improves interactive passthrough in vix run. Console applications now forward stdin correctly and display runtime prompts immediately without delayed buffering. PTY behavior was also improved by disabling local echo for forwarded runtime input. This fixes issues where interactive C++ programs could behave differently under Vix compared to direct terminal execution. For a runtime-focused CLI, stdin, prompts, and interactive applications must behave predictably. This release makes that path much more reliable.

Optional HTTPS support

Vix.cpp v2.5.2 adds optional HTTPS support in vix::core. TLS can be enabled from configuration using:

SERVER_TLS_ENABLED
SERVER_TLS_CERT_FILE
SERVER_TLS_KEY_FILE

The HTTP session layer now runs over a generic transport abstraction. Plain HTTP sessions use PlainTransport. HTTPS sessions use TlsTransport. The release adds TlsConfig, TlsSession, and TlsTransport, and updates HTTPServer to start plain HTTP or HTTPS sessions depending on TLS configuration. The server ready banner now displays HTTPS: when TLS is enabled. The recommended production model remains clear: run the Vix HTTP core behind a TLS-terminating reverse proxy such as Nginx, Caddy, or Traefik. Built-in HTTPS is intended for local development, internal tools, and simple self-hosted deployments.

Transport abstraction

The new transport boundary separates the HTTP parser and session layer from the underlying connection type. This is important because a server session should not be permanently tied to a plain TCP stream. By introducing PlainTransport and TlsTransport, Vix creates a cleaner foundation for connection handling while preserving the existing plain HTTP path. The release also adds native TCP socket handle access in vix::async::net::tcp_stream, which helps transport adapters integrate with lower-level socket behavior.

Script detection and execution pipeline

Vix.cpp v2.5.2 generalizes Vix include detection in the script pipeline. Any include matching:

#include <vix/...>

or:

#include "vix/..."

is now recognized automatically. Any usage of the vix:: namespace is also detected as Vix runtime usage. This removes the need to maintain a hardcoded list of Vix modules in the script probe. New modules can now be detected without updating the probe manually. The script execution pipeline was also improved so lightweight headers such as vix::print and vix::input no longer force unnecessary CMake fallback.

Highlights

  • Added a stable options-based vix::print(...) API.
  • Added vix::print(vix::options{...}, ...) for Python-like print customization.
  • Added a simple interactive vix::input(...) API.
  • Added modular runtime error rules in the CLI.
  • Added diagnostics for concurrency errors, invalid container access, iterator misuse, dangling std::string_view, and dangling std::span.
  • Added modular template error rules.
  • Added diagnostics for concepts, constrained overloads, coroutine protocol failures, slicing, invalid overrides, and downcasts.
  • Added single-file binary export in vix build.
  • Added --bin and --out for direct executable output.
  • Added cross-compilation support for single-file builds through --target.
  • Added runtime target support in vix run.
  • Added Docker, container, SSH, HTTP, and HTTPS runtime targets.
  • Added automatic runtime argument forwarding after the target.
  • Added direct binary execution through vix run ./app.
  • Added smart target resolution in vix run.
  • Added optional HTTPS support in vix::core.
  • Added TlsConfig, TlsSession, and TlsTransport.
  • Added App::run(const vix::config::Config&) and App::listen(const vix::config::Config&, ...).
  • Added native TCP socket handle access in vix::async::net::tcp_stream.

Compatibility

Vix.cpp v2.5.2 introduces no breaking changes. The existing print API remains compatible. Existing nlohmann::json and Simple.hpp response helpers remain supported while core JSON handling continues to move through vix::json::Json. Built-in HTTPS support is optional. When vix::core is built without OpenSSL support, Vix keeps graceful fallback behavior. The recommended production deployment model remains a TLS-terminating reverse proxy in front of the Vix HTTP core.

Notes

Vix.cpp v2.5.2 strengthens both ends of the developer workflow. At the small-program level, it improves print, input, single-file builds, binary export, direct execution, runtime target resolution, and interactive terminal behavior. At the systems level, it improves concurrency diagnostics, template diagnostics, coroutine diagnostics, transport abstraction, and optional HTTPS support. This release makes Vix.cpp more practical as a daily C++ runtime tool while continuing to reinforce its native systems foundation.