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.
Live++ does not require any IDE plug-ins or similar. Use any text editor or external tool for changing your application's source code.
Live++ uses the native toolchain which the executable was built with for compilation, and does not parse any source code.
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.
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.
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.
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++.
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.
Live++ does not care about what your C++ code looks like, as long as you meet the technical requirements. You don't have to rewrite parts of your code to make Live++ work.
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.
Live++ does not care about which IDE you use and therefore supports executables and DLLs built using the following out of the box:
Visual Studio 2010-2017 (all editions, including VS Community and Express editions)
- Visual Studio Code (*)
- Qt Creator IDE (*)
- JetBrains CLion (*)
(*) when using the Visual Studio compiler/MSVC toolchain
Live++ is fully compatible with external build systems. In this mode, changes are compiled by an external build system, while Live++ picks up new code from .OBJ files and links it into the running executable.
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 libraries.
As long as Live++ is enabled for your module (.EXE or .DLL), hot-reload will just work!
Integrating Live++ is very simple and usually requires less than 10 minutes:
- Adapt compiler and linker options to meet the technical requirements.
- Load the Live++ DLL and register a process group with a single line of code using the provided single-header C++ API.
- Enable Live++ for your module (and optionally its import DLLs) using another single line of code.
Read the online documentation for a quickstart guide
Starting with Unreal Engine 4.22, Live++ is deeply integrated into the engine itself and is available to every Unreal Engine developer out of the box.
See it in action
Additional C/C++ API
Live++ comes with an additional API that allows you to do even more advanced hot-reloading, which would otherwise be impossible.
Live++ offers pre- and post-patch hooks that allow you to even make changes to the memory layout of classes. Code like the example below allows you to add and remove members to and from classes.
Even though patching running executables using Live++ is always safe, the API enables you to emit synchronization points into your executable, ensuring that code patches are always applied at e.g. the start of a single frame.
The Live++ API offers additional features such as temporarily disabling optimizations for functions or files - check the online documentation for more information!
Program debug database
Live++ needs a full PDB file in order to extract some of the needed information about the executable.
Hot-reload requires the Live++ DLL to be loaded by your module.
Visual Studio compiler
Code needs to be compiled using a Visual Studio compiler (**).
Code can be linked using either the Visual Studio linker or a custom version of LLD (available upon request).
(*) Subject to change, requirement might be removed in future versions
(**) Support for LLVM Clang in progress
€11.90 / month (excl. VAT)
/ year (excl. VAT)
(save 2 months vs. monthly purchases)
- For commercial purposes, must be purchased with private funds
- License for professionals
(e.g. freelance programmers)
- Includes command-line tools for automated license management
- Per-seat licenses
- 50% discount for students and teaching staff available
€19.90 / month (excl. VAT)
/ year (excl. VAT)
(save 2 months vs. monthly purchases)
By downloading any software of Molecular Matters GmbH from this site, you acknowledge that you have read the End User License Agreement (EULA), and that you understand and agree that you are bound by its terms and conditions.
Minimum system requirements: Microsoft® Windows® 7 32-bit or 64-bit.
Frequently asked questions
Supported IDEs & debuggers
Supported compilers & settings
However, Live++ works in a very generic way, with only a handful of cases that need compiler-specific treatment. Support for LLVM Clang is already in progress and almost finished.
Required code changes
Live++ has been tested extensively on several codebases and game engines of varying sizes. If you have followed all the required steps outlined in the online documentation and checked the FAQ for common mistakes and problems, but still cannot get Live++ to work with your setup, please do not hesitate to contact us directly.
We want to make Live++ work for everyone.
Short-term (Q2 and Q3 2018)
Make Live++ work directly with individual translation units that are part of an amalgamation. This should greatly improve recompile times when working with amalgamated builds.
Allow recompiling and patching code while the process is halted in the debugger.
Allow recompiling and patching code when a process crashes (e.g. caused by an access violation). This allows applications to recover from certain errors without having to perform a restart.
Pass context containing names of all types which had their data layout changed.
Make Live++ work with Clang on Windows.
Make Live++ work with LLD on Windows.
Available in version 1.3.0.
Uses a custom version of LLD available upon request.
Long-term (Q4 2018 and later)
Make Live++ support Xbox One.
Make Live++ support Linux.
Allow recompiling and patching code over the network on multiple machines running multiple processes.