Features

• 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: almost all information is kept in a separate process.

• Unity/Jumbo/Blob splitting

  Live++ automatically detects and splits unity/jumbo/blob files. This fully harnesses the shorter compile times provided by unity builds while also delivering excellent single-file iteration times.

• Additional Visual Studio support

  For users working with Visual Studio, Live++ offers a few built-in features that make working with Visual Studio and Live++ even more convenient.

• 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.

• Hot-Restart

  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.

• Hot-Fix

  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 the cleanup of local variables.

• Hot-Deoptimize

  Deoptimizing code on the fly helps you strike a balance between your application's debugability and its iteration time.

• Multi-process editing

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

• Networked editing

  Live++ supports both local and remote processes, allowing you to hot-reload changes into client/server applications and multiplayer games.

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