# Joovy - Faster compilation

**URL:** <https://discourse.julialang.org/t/joovy-faster-compilation/137945>\
**Category:** Tooling\
**Created:** [July 5, 2026, 7:13am UTC](https://discourse.julialang.org/t/joovy-faster-compilation/137945 "2026-07-05T07:13:01Z")\
**Posts on this page:** 1\
**Showing post:** 1

<div class="post-metadata">

**Author:** ![madppiper](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/madppiper/32/220029_2.png) [@madppiper](https://discourse.julialang.org/u/madppiper)\
**Post date:** [July 5, 2026, 7:13am UTC](https://discourse.julialang.org/t/joovy-faster-compilation/137945/1 "2026-07-05T07:13:01Z")

</div>

Hey,

Paul here, the guy behind [Flexible Julia](https://plugins.jetbrains.com/plugin/29356-flexible-julia). So there’s been a couple of posts regarding Julia performance that have been bugging me (in particular this one: [julia-debugging-is-extremely-slow](https://discourse.julialang.org/t/julia-debugging-is-extremely-slow/)) by @tue. So i started to mess with different ideas on how to improve it further. And being a Java guy, I thought, maybe we just miss something like Groovy for Java (only for Julia), ie. a compiler that optimizes when something is being compiled.

* * *

**What’s Joovy.jl** :  
I built a compilation layer that makes Julia feel faster during development by not compiling everything at full optimization upfront. It is called **Joovy** and you can find it here: [github.com/ilscipio/joovy](https://github.com/ilscipio/joovy)

* * *

**Explainer:**  
Julia’s compiler is thorough. Every function you touch gets fully optimized before you can use it. That is great for production code but painful during development. Precompilation is also incredibly slow, since you compile all dependencies in full. Regardless of what is needed to execute.

So Joovy is like an addon to the compiler. Instead of compiling everything at full optimization, Joovy uses three tiers. Tier 0 is basically not-compiled. Fast to load, but slow to execute. Tier 2 is native Julia. Tier 1 is the middle ground. It does lazy module loading. When you open a file, Joovy parses it and builds a dependency graph but compiles nothing. When you actually call a function, it compiles that function and its dependencies. Everything else stays untouched. External packages get the same treatment through configurable dev-mode tiering. Functions start at tier 1. If you call them enough, they get promoted to native speed (tier 2) in the background. You never wait for the full compile on first use.

So this is not Revise.jl or Julia compiler, it sits in between as a way to optimize how something is processed. (Revise compiles and hot-swaps on existing code, native compiler handles the full packages, Joovy optimizes when compilation happens).

* * *

**Experimental**

This is all **experimental** at this point. I built it primarily for Flexible Julia so the IDE can handle compilation more intelligently behind the scenes. And you can turn it on there in the settings (requires a repl restart). But the package works standalone too. Since this is all new, it is of course possible I messed up. Maybe my own experiment result are misleading, maybe it is not working everywhere. Who knows - but this should improve over time.

If you are curious, check it out: [GitHub - ilscipio/joovy: Dynamic compilation engine for Julia. Tiered optimization, lazy modules, and hot-swapping at runtime. · GitHub](https://github.com/ilscipio/joovy)

Feedback and bugfixes welcome. If anyone has thoughts on the approach or wants to poke holes in the design, I am all ears. Obviously, this is experimental for a reason at this point…

Oh and: this is open source. So anyone who wants to contribute is well invited to do so. Fork, expand, create PRs or do whatever.

---

_[View the full topic](https://discourse.julialang.org/t/joovy-faster-compilation/137945)._