What is Recode?

Recode is a development tool that allows you to safely and reliably update and debug C++ code in running processes without restarting.


  • Edit almost anything (including header files and templates).

  • Add, modify and remove functions.

  • Add and remove global variables.

  • Edit virtual functions.

  • Disable optimisations at runtime - allows debugging without sacrificing performance.

  • Update multiple processes at the same time - perfect for multiplayer development.

  • Extensive support for DLL’s, TLS and more esoteric features such as static locals.

  • Heavily optimizes build performance for unity file builds.

  • Minimal or no code changes required for integration.

  • Minimal runtime impact when enabled.

  • No runtime impact when disabled.

  • Supports distributed compilation (ie. Incredibuild & FastBuild etc).

  • Supports 32-bit and 64-bit processes.

  • Supports optimized builds.

  • Supports VS2017/19/22.

  • Supports LLD-link for faster link times.

  • Direct support always at your fingertips via

Why use Recode?

Recode is designed to allow fast iterative development while retaining the full power and performance of C++. So, if you’ve ever found yourself:

  • Building and retesting repeatedly to make iterative changes.

  • Losing your debug reproduction state in order to try a code change.

  • Forgetting what you were supposed to be doing after yet another build-restart cycle.

  • Wishing you had some C++ features/performance in your scripting language.

  • Struggling to debug an optimized build.

  • Finding multiplayer development painful and slow.

Then Recode might well be for you. In broad terms, Recode is designed to:

  • Reduce development stress.

  • Meet deadlines.

  • Speed up iteration.

  • Reduce crunch.

  • Allow you to leave on time.

  • Improve code quality by making on-the-fly fixes viable.

  • Avoid soul-destroying and concentration-busting debug-build-restart cycles.

  • Ease multiplayer development.

  • Make working in C++ much more fun and enjoyable.

  • Allow you to be creative in your code.

  • Be a realistic alternative to scripting languages.

  • Not get in the way.

  • Just work.

If any of that sounds good, read on…!

Who is Recode for?

Recode is for busy programmers working on large-scale high-performance C++ projects. The main focus for Recode is on games and content creation applications but any GUI based applications can benefit from Recode.

Will Recode impact runtime performance?

Recode is designed to have a minimal impact on runtime performance when used. Since the original binaries are unchanged Recode should have no impact on performance when not in use.

Will Recode impact build times?

No. Although you will need to ensure the Recode compatible complier and link options are set.

Do I need to change my code?

Recode is designed to just work, and in most cases will require few if any changes to your code. However, if your code makes extensive use of esoteric C++ or Microsoft specific compiler features you may have to make a few modifications in order to take full advantage of Recode.

Code Troubleshooting details a few areas that you should be aware of.

Can Recode replace scripting?

Recode can be an excellent replacement for scripting where scripting is in use solely for fast iteration by experienced programmers. Recode offers the following advantages over traditional scripting languages:

  • Native C++ runtime performance (often 10-100x the performance of interpreted scripts).

  • No memory overheads that come with scripting engines.

  • No need to integrate special scripting interfaces to the C++ code.

  • Use the powerful Visual Studio debugger directly.

  • Much less confusing call-stacks during debugging.

  • No need to learn a new language.

  • No restrictions on porting code to console as everything is native C++.

  • The entire C++ codebase can be accessed, not just those elements exposed to scripting.

  • Predictable overheads, no unpredictable GC and performance characteristics typical with scripting engines.

  • Direct access to native types and memory.

  • Type safety.