Open-source project
timholy/Revise.jl avatar
timholy/Revise.jl

Revise.jl applies your edits on the next REPL command, and the readme is 214 words long

Automatically update function definitions in a running Julia session

1,364 stars123 forksJuliaNOASSERTION

At a glance

What is it?
A Julia package that removes the restart cycle from the edit loop: change a source file mid-session, switch a git branch, update a package, and the change lands before your next prompt. The readme is a signpost to a documentation site, credits a specific upstream language fix, and tells you to report your bugs before falling back to an older release series.
Who is it for?
Revise.jl is one of those packages that changes how you work rather than what you build, and for Julia the restart cycle it removes is unusually expensive because of ahead-of-time compilation costs on load. Two things to do first.
Can I use it commercially?
Check first. The repository uses a licence we do not classify automatically, so read its LICENSE file before any commercial use.
Is it still maintained?
Yes. The repository last received commits 4 days ago.
What is it written in?
Mainly Julia, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • timholy/Revise.jl1,364 ★ · +9
Star history
Repository2026-09-112026-11-15
timholy/Revise.jl1.4k1.4k

9 Stars in the last 65 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The entire loop is: edit a file, then type your next command

The description fits in one sentence, which is a compliment.

Revise lets you modify code and use the changes without restarting Julia. The workflow it targets is being partway through a session, then updating a package, switching a git branch, or editing source in whichever editor you use, and having the change taken up by the very next command you issue from the prompt.

The word the readme uses is typically, and that hedge is doing real work. It is not claiming your edit is applied before you finish typing, and it is not claiming every change is safe to apply. It is saying the loop closes on the next command rather than at the end of the session.

What that saves is named precisely: restarting Julia, loading packages, and waiting for code to compile. In a language that compiles on demand, that wait is the dominant cost of a small edit, and for a package with many dependencies the load time compounds it. Removing that cost is not a convenience; it changes what iteration feels like at the end of a long session.

The mechanism behind it is not documented in the readme at all, which is the first sign that this repository treats its documentation site as the real interface.

The readme is a signpost, and the configuration answer lives in the docs

The readme for this package is short enough to read in under a minute, and that is a deliberate choice rather than an unfinished document.

It states what the package does, links the documentation twice, and then stops. The documentation site is a separate published site with a stable path, and the readme links into it at a specific section for the question most new users have.

That question is how to make it run automatically, and the answer given here is the useful part: most users will want to alter their startup file under the Julia configuration directory so Revise loads by default. That is a one-line change to a file you probably already have, and it is the difference between a tool that is always there and one you remember to type.

Everything else is deferred: what happens on conflicting definitions, how it interacts with precompilation, how it handles generated code, and what its limits are. None of that is in the readme.

For a package with three releases in a month and a long history, that is a reasonable division of labour. It does mean the article you are reading cannot tell you the failure modes, and the first thing to expect is a trip to the documentation site.

Both current release series step through module-defining code with an interpreter

The release notes contain one piece of architectural information, and it explains why the package works at all.

Both the current 3.x cycle and the 2.x cycle use an external interpreter package to step through your module-defining code. That is the whole reason a running Julia session can incorporate a change to a method defined inside a module: the interpreter evaluates the new definition in the right world rather than hoping a plain redefinition is sufficient.

The readme frames this as a note about major releases rather than as a design document, which undersells it. Depending on an interpreter for the central operation means two things. Your edits are evaluated rather than trusted, which is slower than a plain assignment but far more predictable when the new definition has preconditions or generated behaviour. And a bug in the interpreter is a bug in your edit loop, which is a dependency worth knowing about.

The version numbers themselves follow the ecosystem convention where a change in the trailing component is compatible and a change in the middle one is not. The three recent releases go from a patch level to a minor level and back to a patch level, so something in the 3.17 line is a breaking change by that convention.

The release history is also kept as a separate news file at the repository root, which is where the per-version detail lives.

There is a fallback release series, and the readme asks you to report the bug first

Most packages do not tell you to use an older release. This one does, with conditions.

The 1.x cycle does not use the interpreter described above, and instead integrates with the package manager directly. The readme's advice is that if the more recent releases give you trouble, try this older series, followed immediately by a parenthetical instruction to report the problems first.

That ordering matters. The suggestion is not framed as a workaround you should keep; it is framed as a diagnostic step. Install the old series, confirm your problem is version specific, then file it so the current series can be fixed. A package that asks for that is telling you it has a small maintainer base and would rather have the report than the workaround.

There is also a branch for Julia 0.6, with a follow-up sentence telling you that you really should not be using that version anymore. That branch exists for people whose environment pins an old release, and the tone of the note suggests it is a courtesy rather than support.

So the support matrix has three tiers, and only the newest one is where fixes land.

Two editors do a subset of this, and the credit points at one upstream language fix

Two parts of the credits section say more about the design space than the feature description does.

First, two editor integrations are named as offering an editor-based mechanism for achieving a subset of what this package does. Both are Julia-specific editors, one of them now the reference extension for the language and one older. So there are three ways to get live editing in Julia: your editor's built-in mechanism, this package, or nothing.

The reason the package exists as a separate option is worth stating plainly. An editor mechanism only works if you use that editor. Revise is editor independent: it hooks into the session itself, so it works in a bare terminal, over a remote connection, in a container, or in a script you are running. For anyone on a headless machine or working over SSH, that is the only option of the three.

Second, the enabling fix. The readme states that the package became possible because of a specific fix to a specific long-standing issue in the language itself, credited by name and linked. That is worth internalising: this is userland code standing on a language-level repair, and it means the package's behaviour is coupled to a change in Julia's own internals.

The credit is specific and dated by link, which is what you want from a project whose core trick came from someone else's patch.

The licence file is at the root, but the platform metadata does not recognise it

One small thing to check before you depend on this package.

The repository ships a licence file at its root, and the licence is the permissive kind that Julia packages of this age almost always use. But the repository's own metadata reports no recognised licence, which means an automated licence check against the project will come back empty.

That is a naming and detection issue rather than a permissions one. Licence files with a markdown extension are not detected by every tool, and this file uses that extension. So if your process reads the licence from the API badge, it will read nothing, and if your process reads the file, it will read the licence.

The repository layout otherwise looks like a mature Julia package. There is a project file declaring the package and its version, and no dependency manifest, which is correct for a library since pinning dependencies in a library is discouraged. There is a directory for package extensions, the modern mechanism for loading optional dependencies without forcing them on everyone. There is a documentation directory, a test directory, an images directory used by the docs, and a coverage configuration.

A news file at the root carries the release history, and the continuous integration and coverage badges in the readme are wired to hosted services rather than self-hosted ones.

Editorial conclusion

Revise.jl is one of those packages that changes how you work rather than what you build, and for Julia the restart cycle it removes is unusually expensive because of ahead-of-time compilation costs on load. Two things to do first. Load it from your startup file rather than typing it each session, since the readme points at exactly that and it is the difference between the tool helping and not helping. And note that this is a userland package built on a language fix by someone else, so if a recent release misbehaves on your version, the documented path is to report the problem rather than quietly downgrade.

Frequently asked questions

What is Revise.jl?

A Julia package that lets you modify code and use the change without restarting the language. You can be partway through a session, then update a package, switch a git branch, or edit a source file in any editor, and the change is typically incorporated into the very next command you issue from the prompt, saving the cost of restarting Julia, reloading packages and waiting for compilation.

How do I use Revise.jl?

Load it, then edit. The readme's recommendation is to alter your startup file in the Julia configuration directory so that it runs automatically rather than being typed each session, which is described in the configuration section of the documentation. After that, editing a source file in your editor and issuing your next prompt picks the change up.

Does Revise.jl work with every Julia version?

It has three tiers of support. The current 3.x cycle and the 2.x cycle both use an interpreter package to step through module-defining code. The 1.x cycle does not, and integrates with the package manager instead; the readme suggests trying it if recent releases give you trouble, but asks you to report the problems first. A separate branch exists for Julia 0.6, which the readme discourages.

Do I need a Julia IDE to use Revise.jl?

No, and that is the reason to use it over an editor's own mechanism. Two Julia editors are credited as offering an editor-based approach that achieves a subset of the same aims, which only works if you use those editors. Revise hooks into the session itself, so it also works in a bare terminal, over a remote connection, or in a container.

How do I report a problem with Revise.jl?

The readme asks for it explicitly when it suggests falling back to the older release series: try the old series to confirm the problem is version specific, then report it so the current series can be fixed. The enabling mechanism also depends on an upstream fix to a Julia language issue, credited by name and linked in the readme, so behaviour is coupled to changes in the language's own internals.

Official sources

  1. Issues
  2. Project website
  3. README
  4. Releases
  5. timholy/Revise.jl on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/timholy-revise-jl.svg)](https://hysenlabs.com/projects/timholy-revise-jl)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/timholy-revise-jl.svg)](https://hysenlabs.com/projects/timholy-revise-jl)

Was this useful?