• Project setup agnostic

    Live++ doesn't care about your project setup. It works with .EXE, .DLL, and .LIB based projects, makefiles, and custom setups and build systems.

  • IDE agnostic

    Live++ does not require any IDE plug-ins or similar. Use any text editor or external tool for changing your application's source code.

  • Native toolchain

    Live++ uses the native toolchain which the executable was built with for compilation, and does not parse any source code.

  • Binary

    Live++ works at the binary level using .PDB, .EXE, .DLL, .LIB, and .OBJ directly. It extracts and reverses most of the needed information from executable and object files.

  • High compatibility

    Live++ is compatible with almost all compiler options, except whole program optimization. It supports linking with the static and dynamic run-time libraries.

  • Extensive C++ Support

    Hot-reload supports all C++ features such as RTTI, polymorphism, exceptions, etc. Live++ inherently supports all compiler-dependent features your code might use.

  • Lightweight

    The Live++ .DLL is very lightweight, adding only ~150 KiB to your application's memory footprint. Almost all information is kept in a separate process.

  • Single-machine multi-process editing

    Live++ lets you simultaneously apply changes to multiple running processes.

  • 32-bit and 64-bit

    Live++ fully supports x86/32-bit and x64/64-bit applications.

  • Special support for amalgamated/unity builds

    Live++ automatically detects and splits amalgamated/unity files. By leveraging a built-in object file cache along with dependency databases, split unity files persist even across Live++ sessions. This fully harnesses the shorter compile times provided by unity builds and at the same time delivers excellent single-file iteration times when using Live++.

  • Powerful error recovery

    With its built-in exception handler, Live++ allows you to change and recompile code in the event of fatal errors such as access violations. With SEH information available, it even supports stack unwinding and cleanup of local variables.

  • Restarting applications

    Live++ offers a mechanism for restarting applications while keeping loaded data and internal caches persistent. This eliminates link times and Live++ loading times between sessions, as Live++ code patches will automatically be injected into the restarted process.

  • External build systems

    Live++ does not care about the build system you use to compile your C++ code. FASTBuild, SN-DBS, IncrediBuild, and various in-house (distributed) build systems have been tested to work without requiring any additional setup.
    Still, Live++ can be put into external build system mode, where changes are compiled by you, while Live++ picks up new code from .OBJ files directly and links it into the running executable. This even allows adding completely new .OBJ files into the hot-reloaded process.

  • Process independence

    Live++ does not care about how an .EXE is started or by which application a .DLL is loaded. It doesn't matter whether you have a main executable linked against several static libraries, a .DLL-based plug-in loaded by a 3rd-party application such as Autodesk Maya®, or a game .DLL loaded by an external application such as a C# editor - Live++ naturally supports all of these scenarios and any mix of modules and static and dynamic libraries.

As long as Live++ is enabled for your modules (.EXEs or .DLLs), hot-reload will just work!