HOT RELOAD - Edit Code Without Compiling!

Hey everyone!

I'm excited to share a new product we just launched - Hot Reload for Unity. It allows you to make code changes and see the updates in real-time. No domain reload, no waiting for editor compiling, and no project changes required.

Check out the demo video here:

The developers in our studio used to struggle daily with very slow iteration times. Our project is currently 2M+ lines of code, and even with months of work our biggest assembly still takes ~45s to compile, not counting startup of the game (~15s), and getting back to where you were (easily ~30s)

That's why we created this extension - to allow for much quicker interactions and iterations.

After several years of using the product in our studio (40 people), we can confidently say that we have a hot reload product that just works - even on massive and complex projects. Our solution does not involve waiting for Unity to compile, nor a Domain Reload; all your in-game state stays exactly the way it is.

You can get it on the Unity Asset Store (Unity Verified Solution) or on our webite

Please let us know what you think!

UPDATE: We recently changed our pricing options, including a cheaper one-time purchase pricing model for individuals and small teams! See the pricing page on our website for more info.


Links
contact@hotreload.net
Walkthrough video
Discord
Issue Tracker

 

Sounds too good to be true, which I hope it isn‘t.

Can you elaborate, at least on a high level, how this works? What are the main limitations or caveats?

 

Hi CodeSmile.

To make it work, we built a custom C# compiler integration (yes, really), and only compile the code that changed. And with that output, we patch up the existing C# code while it's running (this part has been done by many games already).

One drawback is that most edits, but not all edits, are supported. For example we're still working on supporting adding/removing arguments in method signatures (at the moment this still requires a normal compile in the editor). This is answered in more detail in the 'What kind of code changes are supported' question on our FAQ.

That said, we're working on it; hopefully in the next week or so, we'll release an update to also support those (undergoing internal beta).

Overall I guess the main drawback is that we're monetizing it rather than open sourcing for free, though we hope to still support some people with the free trial and a permanent free tier.

We'd love to hear your feedback though!

 

Monthly subscription is often difficult to handle inside company,
rather have fixed price, then optional paid updates every year or version or so..

*of course it has possibility to save time and that amount of costs in many companies (in saved compilations times),
but in our case it wouldn't be used in every project, so would prefer fixed..

 

Hi mgear.

We're definitely open to price suggestions, so thanks for the feedback. Can you please clarify what you mean by "in our case it wouldn't be used in every project"?

Hot Reload should work in every project, and I believe it's useful even in the smallest of projects. But maybe you mean something else?

 

Yeah i mean outside game dev, at work,
if we do projects for different customers, most of those wouldn't really need hot reload.. (if scripting is really simple too).
But for example if its mobile or quest app with more complex scripting or so, then of course this would be more useful during that time. (but often not so many of those projects)

 

Thanks for clarifying. I suspect our upcoming free tier will be sufficient for project with minimal scripting, but I understand what you mean about the subscription being active even though you might not always need it.

We'll re-evaluate pricing in a few days, based on your feedback and feedback from a bunch of people that are currently trying it out.

If you have any feedback on the product, feel free to leave a message here!

 

We just released a new QuickStart Setup & Demo video which pretty much goes through the whole process from downloading it to getting it running in a demo project. Took less than two minutes to get it running!

Check it out:

 

Does this support projects with significant amounts of code generation?

I'm thinking about how this could apply to Unity DOTS where even a single line change that contains SystemAPI would require a complete regeneration of the entire system class / struct. Does your modified compiler recognize and follow the changes in code generated files along with the original file?

And how does this work with Burst and Burst compiled methods / jobs?

 

I haven't tried this yet, but if it's as effective as advertised this could be very cool indeed. However, at the micro solo indie level that I'm at, I can't justify the fairly steep price. Selfishly, I'd like to see an indie license that does the free if revenue below X thing.

If this doesn't support Burst - which I imagine it won't - that may put a bit of a dampener on things.

It's somewhat embarrassing if this delivers on Unity's infamous 500ms reload promise which they're still orders of magnitude away from themselves. Probably the best thing for everybody would be for Unity to buy this out and incorporate it officially.

I'm curious about the "C# compiler integration" - do you mean that you're using the Roslyn API to create IL patches?

 

Our compiler works the same way as the default compiler used by the Unity Editor. Changing many files is by itself not a problem, dependencies between files are tracked correctly.
So it'll work as expected, so long as all the edits made are inside functions (currently newly created classes/field require a full recompile. But we're actively working on implementing support for it).

In our own projects, we have only tested editing code handled by the default C# compiler. I'm not fully aware of all available Burst setting, if there's a setting to compile using the default C# compiler then Hot Reload will just work.

Feel free to let me know if Burst support is very important to you, we might be able to support it in the future.

 

Thanks for the feedback, I suspect/hope our upcoming free tier will cover a large part of the use-case for smaller devs/indies. But we'll definitely re-evaluate after it people had a chance to try the free tier.

Hypothetically speaking, if the free tier isn't suffficient, would you a larger one-time purchase make more sense for you? eg $200

About the implementation, we have large amounts of self-written compiler code, Roslyn only supports a small subsection of what's needed. I hope this helps to understand the price point, a massive amount of work and expertise was required to pull this off

 

I assumed that was intended as more of a demo. 15 reloads per day is a tiny number. The value comes from being able to iterate rapidly like you show in that video, where you do 4 reloads in 30 seconds. I'd burn through the 15 per day in five minutes - it's essentially useless as far as I can tell. Perhaps I've misunderstood the indie license.

A one time purchase would be easier for me to justify, but I probably wouldn't pay that much at my current size. I can see that the value is easily there for sizeable teams, but at my level I would struggle to justify that - especially if it has lots of caveats around Burst, as most of the logic I would want to tweak ends up in Burst code.

However, if you had a "free if your revenue is below $50k per anum" option, your product would probably become an essential part of my workflow and you'd get my money when my business grows.

Wow okay, that's incredibly fair with regards to value. I'd urge you to see if you can find a way to get paid by Unity rather than by individual users. They've got bags of cash, they know that their iteration times are a painful joke, and 500ms is one of their most famous broken promises. This should be the default Unity experience for everybody.

I'm a little worried by the compatibility of your custom compiler situation. Unity - particularly in Burst and DOTS world - does a lot of custom IL rewriting as part of its compilation pipeline, as well as calling out to the Burst compiler. How much of that is supported by your current process, and how much is reasonably supportable in the future?

 

$99.99/month for a Plus subscriber for just hot reload when I pay $30/month for the whole Adobe suit, and around $10 for Rider. As much as like the idea of hot reload, the pricing seems a bit overstated and Indie license includes only Unity Personal as far as I can tell. But even then $30 a month for just hot reload is hefty when it doesn't offer near the value of my other subscriptions, yet costs the same or more.

I guess for massive projects where compile times are actually in minutes; it makes sense financially. But you're unlikely to attract the indie crowd at this price point and with Unity Personal limitation.

 

I understand what you mean, if I'd be iterating on something very specific, I'd also use tons of reloads. I had a wrong perception because at the stage in the project where we are now, many our developers get through almost the full day with only 20-30 reloads. But I think it's quite specific to our workflow, hence the disconnect.

So overall, an unlimited free tier for Unity Personal makes sense to me. We'll include it one of the next releases!

I hope you guys don't mind me asking, but at what price would you consider it affordable?

For example, this is Rider's pricing
- $14.90/mo ($12.4/mo yearly) for Individuals
- $41.9/mo ($34.9/mo yearly) for Organizations (Rider charges companies this price regardless of yearly revenue)

 

One of the devs will have a look and get back to you (pencilbow9)

 

Hey. I can guarantee that our solution has exact compatibility with the default C# compiler. DOTS and
Unity.Jobs work fine, tried it just now.

Burst compiled functions are unfortunately incompatible, edits to a [BurstCompile] function won't apply, it'll just be ignored.
Of course you can still edit other functions, even if they're in the same file or assembly as the burst compiled function. We'll fix it up so BurstCompile/BurstIgnore attributes are taken into account and give a more descriptive error/warning.

As a quick workaround, you could consider removing the [BurstCompile] attribute in the editor if you need to quickly iterate. Eg you might add a compile flag around the attribute, so that you can easily disable it if you're working not currently working on performance.

I do understand this is still a hassle. If Unity would grant us access to use the burst compiler, I'm sure we could integrate it seamlessly. But with Unity's ToS/ Distribution License, I believe we're not allowed to decompile or modify in the way we'd need to.


As a small aside, I'd love to hear if you have an feedback on the existing asset. In case you do try it out, we should have the permanent free tier before your free trial runs out (7days), so you'll be able to continue using it.

 

I'm evaluating it now. I get this error on file change:

[HotReload] Step 3 was not successfull: error CS7038: Failed to emit module 'Assembly-CSharp': Changing the version of an assembly reference is not allowed during debugging: 'Newtonsoft.Json, Version=13.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed' changed version to '11.0.0.0'.
UnityEngine.Debug:LogWarningFormat (string,object[])
SingularityGroup.HotReload.Editor.HotReloadWindow:RegisterWarnings

The file I am changing does not use Newtonsoft.Json. Is there anything I can do to work around this error?

 

This has great potential, and, in my scenario, it would be worth $30/month. I think the pricing is steep given that it exceeds what I pay to license an accounting system and Unity. But I think it can work because it will save time in the long run. The holdback for me is that I am not going to give up having an attached debugger.

 

OK, one more question. If directory changes are disabled for this plugin to work, what is the alternative guidance on refreshes? Do I need to refresh the specific file and/or directory when assets are imported?

 

I honestly think you guys should implement a percentage based approach, and make indies or the free tier unlimited as we already have agreed upon.

For example:
Your business model is practically designed for big enterprises, now imagine if you had a company that generated 100_000 a year and you took 10%.

You would get 10_000$ yearly or 833$ monthly, that's equivalent to ≈39 to 56 people paying for your service, at the price of the Rider IDE monthly, especially when a company will pay consistently, where an indie or solo otherwise wouldn't!

And this is only if they generate 100_000$!
I found a graph on What can we learn from the 1,600 highest earning indie developers on Steam? (gamedeveloper.com) that showcases company revenue in numbers from a steam survey.



Now imagine what would occur if one of those success story developers ended up using your product!

What you need is a really good advertising campaign and a good product (which you already have!), so I imagine that under these conditions this project could bloom pretty quickly!

Hope this helps.

 

This all sounds very exciting, thanks @reese015 and @PencilBow! I'll definitely check it out. I'll start the trial when I'm next doing a significant amount of work in Unity, which will probably be tomorrow.

I assume that you'll never be able to accelerate the compilation of Burst code itself, because that compiler is a whole separate beast. However, Burst already has asynchronous compilation. Unity initially runs the plain managed C# code, then hot-swaps in the Burst compiled code when compilation finishes. The ideal behaviour would be:

1. User makes edit to Burst compiled code
2. HotReload recompiles the plain C# version, and loads that in immediately.
3. The Burst compiler is triggered to recompile it asynchronously.
4. Unity hot-swaps the Burst compiled code in in the normal way.

It's been a while since I last poked around in the

Unity.Burst

namespace, but they do expose a reasonable amount of low level stuff that might be sufficient to get this working.

For me personally, Burst is fairly important because 90% of my gameplay code ends up being Bursted. I tend to use thin MonoBehaviour layers over custom code. Most of the time, I don't actually need the Burst speed to hit the target framerate in the editor, I just Burst compile things to be respectful of user's energy usage and to aim for lower spec hardware. I probably could simply temporarily disable all Burst compilation in the editor when using HotReload, but it's not ideal.

As a small aside, I might politely suggest that you reconsider the name of your product. Giving your tool the same name as the generic term for the feature is likely to cause some confusion. E.g. I had to use the phrase "hot-swaps" to describe what Burst is doing to avoid confusion, but normally I would have called that hot reloading.

 

Definitely the current naming could confuse people and wouldn't allow you guys to build a name for yourself

 

The issue can happen if you recently changed a dll, I'm publishing a fix for it now. As a workaround, you can clear your Library/ScriptAssemblies folder and restart the editor.
New version will be live in ~30minutes

 

Just to clarify, you can still attach the debugger. Though debugging indeed (currently) doesn't work for edited functions, is that what you meant?

 

If I understand correctly, you're referring to the editor's Auto Refresh. You can manually trigger a refresh with CTRL+R, the editor will figure out what needs to be compiled. You'll want to do this whenever you make an unsupported edit, eg adding a new class. You'll get a clear warning when this does happen.

Do note that after you make an unsupported edit, you can often still continue editing unrelated files/functions. Your unsupported edit just won't show up.

 

Good to know. It was giving me some kind of error/warning saying it couldn't run because a debugger was attached, I think. I'll try again.

 

Interesting but I guess it won't work for multiplayer projects that use mono.cecil or source generators?

 

We support anything where you edit the C# code, and then that code runs directly. So source generators that output C# files are fine, assuming the generator's changes are supported edits.

If I understand correctly, Unity's multiplayer-hlapi generates a dll from basically a template language (in c#), we currently don't support this.

 

Hlapi, Mirror, Fishnet, Photon use cecil to replace and inject code. Happens in Unity.CompilationPipeline.Common.ILPostProcessing.ILPostProcessor on asmdef recompilation.

I agree that price is too high, adding 20% VAT in EU, most won't prepay full year for new software so we end up with $120/m.

That's how much Rider costs me for full year that I can use for both work and personal projects. https://sales.jetbrains.com/hc/en-g...-use-my-personal-license-at-work-and-at-home-

 

Had a look at Mirror now, indeed networked functions are not hot reloaded right now. Static functions and non-networked functions like Awake/Start/Update etc still work.
That said, the libraries' IL post processing is something we actually could support on a case-by-case basis (different for each library). Is this currently a deal-breaker for your team?

Regarding the price, are you using Unity Plus? We're considering to move Unity Plus users to $24.99/mo (yearly). And VAT charges shouldn't apply if you enter a VAT number during checkout, so that's a 20% discount

 

Not really as my projects are optimized enough to recompile under few seconds and test scenes fix load issues. Using https://assetstore.unity.com/packages/tools/integration/roslyn-c-runtime-compiler-142753 with another (open source) C# runtime for live coding even in il2cpp builds but it's not as easy to use as this package (and also doesn't support cecil/source gen)

I've read "Unity Plus users for $24.99/yearly" for a second, that would work, haha.

Anyway congrats on doing what Unity promised for years, ill wait for net core in Unity and their limited hot reload.

 

May I ask what the advantages of this solution are vs. this?
https://forum.unity.com/threads/rel...d-1-play-2-make-change-3-see-results.1361971/
How comes you need to ship an additional compiler while he apparently didn't?

 

Fast Script Reload's architecture is very different. Basically FSR is rewrite syntax using the Roslyn API (a dll), so it doesn't need to ship with more. But using syntax results in a fragile solution that breaks as soon as your project becomes sufficiently complex. We considered this approach when making Hot Reload, but decided against it, even it would have been much easier and quicker to make.

For example, FSR breaks if:
- you use any extension method. 'MyFunc(this MyClass)'
- you have any code with ambiguous syntax. For example a name that might be used in 2 different dlls, an implicit operator, etc.
- you edit something involving Generics
- you edit something that is referenced across files

I spent multiple hours trying to edit something in our main project using FSR, and wasn't able to make it work, every single file had some kind of unsupported feature, preventing me from editing anything. I do suspect it will sometimes work in smaller projects. A friend tried it on his small project, and about 50% of files eventually worked.

Some more differences in addition to the fragility:

- Our reaction time is <300ms in a small project. FSR is always 3s
- On large files FSR becomes slow (I've seen 30s on 3000 line files). Our solution is fast regardless of file size, as we only compile the function that changed.
- We will support method renames, adding/editing arguments, generics (implemented and being tested in-house)
- FSR uses a polling file watcher, meaning CPU usage goes up if you have a lot of files. With Hot Reload you don't have this issue, and you also don't need to maintain a whitelist of folders you want to edit.
- We have support planned for adding/editing fields, adding classes, and whatever the community wants most. Since we work on the compiler-level, we can robustly support most C# features.
- We support MacOS with Apple Silicon processors (models released after 2021). FSR crashes at the moment. Implementing support for this was non-trivial.

 

Rider gets cheaper the longer you sub. I pay around $120 (incl. VAT) yearly as a longtime subscriber, which comes down to $10/month.


And again, Rider is a whole IDE with powerful refactoring capabilities. It's essential to my productivity and even at its most expensive tier costs half as much as HotReload. Same with Adobe apps, I can't run Photoshop scripts without Photoshop. You are pricing HotReload similarly to these tools and services, yet HotReload is not essential to what I do because my compile/domain reload times are sub 5 seconds, even for mid-sized indie projects which are my main bread and butter. But even larger two-year projects are unlikely to exceed 10 seconds. While I'd still like to eliminate that wait time and be able to more rapidly iterate, it's not essential like the aforementioned tools.

You also specify that to qualify for HotReload Indie license, you can only have Unity Personal. Plus subscribers are required to get the $99 business tier at more than thrice the price. But there are plenty of indies and Unity based freelancers that sub to Plus yet don't exceed the 100k/year revenue limit. Plus has features like Unity splash screen editing/removal and mobile specific features not included in Unity Personal. I'm one of those freelancers.

Personally at $10+VAT/month and assuming Unity Plus is included in HotReload Indie license, I'd consider HotReload affordable. Anything over $20/month for a nice to have but non-essential utility is a strong no from me.

I can't really comment much on the business tier. At 2 minute compile times your value proposition makes sense for American wages, but the rest of the world does not really have over $100k/year salaries.

 

I think ultimately how valuable this tool is varies significantly for everyone. You have this example calculation on your website showing that it can save $881 per developer - in that case the suggested prices are a really fair deal and make sense.
In my country the average salary is much lower though, and on our project the compile time is significantly lower too, which for us would put that calculation at ~$95 saved per developer per month, so paying $80 seems pretty steep.

I don't want to downplay how complicated it was to build in any form and I'm very interested in using it for the added comfort, it's just that for our situation the price/value ratio looks differently and wouldn't really justify getting it.

 

Thanks for feedback, it's much appreciated We've indeed been very much focused on the use-case of bigger studios in specific regions, which is clearly not everyone.

If you don't mind sharing, I'd be curious
- Are you using Unity Pro? (don't have to share if confidential)
- Assuming you expect to save $95/month, would you consider buying it at ~$30/mo (non-yearly plan)?
- Does $95/month also include time saved from not having to starting the game and get back to where you were?

 

The power of interactive programming comes from making small changes. The free reloads should be more like a 100 or so I could test it at its real potential for a little time.

 

Stay on topic and grow up. Childish internet slap fights are unacceptable here. Offending posts have been removed and trolls have been banned.

 

I've talked to some (gamedevs) friends, and this is what everyone liked most:

Unlimited usage for 120 minutes a day, usable in 4x30minute sessions.

The session timer is started manually whenever you like. And of course you could use all the sessions back-to-back. We'll also auto-start the next session if you hot reloaded something in the last 2 minutes, to avoid breaking your workflow with a manual button click.

Would love to hear if anyone has feedback on this.

 

This Hot Reload tool is doing wonders to my project!
My project usually has 20~30 sec assembly reload times, and this tool helps me avoid those wait times.
Now, my code changes are reflected pretty much instantly.

Thanks a lot for developing an usable Hot Reload feature for Unity
As others said above, Unity really should take a look at this tool and maybe buy it and integrate it to the engine

I'm interested in this. This would help popularize the Hot Reload tool A LOT with the indies.
Any ETA on this being added anytime soon?

 

Looks like pricing page has changed but no idea how to get free 2h or personal license.

 

Glad to hear it's working out for you. If you have any contacts at Unity, do send them a message

ETA for free tier is 1-2 days. So unlimited for Unity personal, and free 2 hours/day for everyone else. All this is in addition to the 7-day free trial (unlimited reloads) we already have.

Definitely also keep an eye out for our upcoming releases, the next big one will include support for generics, adding/removing parameters, renames, and more. (ETA 5 days)

 

Kamyker, we're still testing the latest release before it goes live. If your free trial is running short and want to get it extended, you can send me a message with your registration email.

 

That's huge, you should definitely add Patreon, Github Sponsors or something similar for donations.

Btw also noticed Plus was moved to Indie tier if someone missed it.

 

Are source generators supported? I'm not asking about edit and run but in general seems like first compilation fails for me.

Dlls with "RoslynAnalyzer" label should be treated as generators. https://docs.unity3d.com/Manual/roslyn-analyzers.html

Another thing I found is that watchman isn't shut down after closing compiler.

 

@zombiegorilla Sorry you had to be tagged again for cleanup (above comment by 'ethrillo').

Is it possible to somehow restrict a thread so that only accounts at least one month old (maybe even only accounts created before 2023) are allowed to post on this thread? Otherwise I can see this happening somewhat regularly since this is likely the same troll that started the off-topic flame war this past weekend.

 

I had a look at it now. We should be able to integrate with the existing source generator API relatively easily. I've added it to the roadmap, someone will try to integrating it in a couple of days.

 

Just report them. They are only wasting their own time, it's only a couple of clicks to get rid of garbage posts.

 

Appreciate the Unity Plus inclusion in the Indie tier. I'm still not happy with the price since I'm not earning American level wages in Northern Europe, but I'll give it a go and see if time saved makes sense financially for me as a freelancer.