Repository navigation
hot code swapping #68
Description
- Have the compiler run continuously, watching the file system for source
changes and automatically perform multithreaded compilation to build projects
quickly. - Hot code swapping. When integrated with the previous feature, you could
press "save" in your editor and see the change immediately in your running
software.
Of course this only works for some kinds of changes - obviously if you make changes to your initialization code, you won't see a difference. But it would probably work at the function level, so you could swap out any individual function for a new one.
Activity
PavelVozenilek commentedon Feb 9, 2016
This feature (automatic rebuild in background & hot code swapping) is available for C++ in Projucer IDE, built upon LLVM infrastructure.
Old demo 1, old demo 2, few implementation details.
Be aware that it took several years to implement and the implementor said that "it was the most complicated thing I ever did".
0joshuaolson1 commentedon May 25, 2018
@PavelVozenilek The Projucer link has died, sadly.
PavelVozenilek commentedon Jun 9, 2018
Information from the dead link is probably here:
https://forum.juce.com/t/demo-screencast-of-the-projucer/9218
and here:
http://web.archive.org/web/20130808104856/http://rawmaterialsoftware.com/viewtopic.php?f=2&t=9794
ccll commentedon Jun 14, 2018
I always wonder how should hot-swap deal with data (data structure layout and long-lived in-memory state), it seems rather difficult compared to hot-swap stateless code (like a pure function).
In some languages which support closure, it's even more complicated.
Are there any articles on this subject?
isaachier commentedon Jun 14, 2018
@ccll that is the biggest issue. Doing it in C/C++ is currently possible using a dynamically loaded library. See this blog post on the topic.
themagnet commentedon Jun 26, 2018
here https://molecular-matters.com/products_livepp.html is a commercial product which realizes hot-reload for c/c++ projects
jaccarmac commentedon Jun 29, 2018
I wonder if looking at the way Common Lisp deals with these things would be useful at all. Sure, CL has a fatter runtime than Zig at the binary level, but:
ccll commentedon Jul 11, 2018
@isaachier Thanks, that article is very helpful!
I can see it passes a DLL-specific 'game_state' around, but what if the layout of 'game_state' got changed between reloads? I can imagine there will be lots of crashes/segfaults/misbehavior.
Now i've integrated C live coding successfully with libtcc, which hot-swap pure code flawlessly.
About the state transition, I can think of a solution which serialize the state out (to a layout-agnostic format), allocate new state, then serialize in. It should work, but involves a lot of manual implementation of serializing code and is not very generic/automatic.
13 remaining items
dischoen commentedon Jan 24, 2022
You could have a look at how it is done in erlang. However, that's a different world..
Another thing, which I haven't seen in the comments so far would be security.
Would an attacker be able to patch production code at runtime?
andrewrk commentedon Jan 24, 2022
I did some live coding on this feature recently, and we got to a proof-of-concept status:
It's in the hcs branch. It depends on further progress on the x86_64 backend to be generally useful. It's also for Linux only currently. Each OS will need its own hot code swapping strategy.
qm3ster commentedon Jul 29, 2023
There has also been https://www.jakubkonka.com/2022/03/16/hcs-zig.html (hcs-macos branch) by @kubkon
acodervic commentedon Nov 3, 2023
I need HRC(Hot Reload Code) , If Zig has HRC It will be perfect language .
jeffective commentedon Aug 26, 2024
Use case: industrial control applications which require "online changes" (ability to change code between control cycles with effectivley zero downtime)
Would want to trigger the hot swap manually and be able to tell if a hot swap is possible or not before attempting.
andergisomon commentedon May 19, 2025
Edit: xoxo
Just adding on to @kj4tmp mentioned, this will be a perfect use case for Zig over Rust, where the borrow checker and
unsafestart to become more of a less elegant solution to guard against UB.