# Interactive development in Julia compared to \[Common\] Lisp?

**URL:** https://discourse.julialang.org/t/interactive-development-in-julia-compared-to-common-lisp/139494
**Category:** New to Julia
**Tags:** question
**Created:** [September 16, 2026, 10:57am UTC](https://discourse.julialang.org/t/interactive-development-in-julia-compared-to-common-lisp/139494 "2026-09-16T10:57:11Z")
**Posts on this page:** 1
**Showing post:** 6

<div class="post-metadata">

### Author: ![Palli](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/palli/32/3380_2.png) [@Palli](https://discourse.julialang.org/u/Palli)
#### Post date: [September 16, 2026, 1:42pm UTC](https://discourse.julialang.org/t/interactive-development-in-julia-compared-to-common-lisp/139494/6 "2026-09-16T13:42:28Z")

</div>

Welcome!

> [@farooqkz](#):
>
> You can even pause any time in your program to change functions, variables, or inspect them.

I don’t know that you can pause at any time in Julia, even when running in the available interpreter. At least in the REPL. There are tools to set breakpoints and more traditional debugging. I believe integrated in the VS Code extension. Lisp (and Smalltalk) are I believe the gold standard in interactive development, and Julia likely best after such languages.

You may want to start out with Pluto.jl, it’s _reactive_, not exactly the interactive experience you’re after.

This seems really cool (just proprietary), showing what possible, but also what you don’t have with current tools, and even this I believe allows no modification:

> [@\[ANN\] CodeGlass – see what your code is actually doing](https://discourse.julialang.org/t/ann-codeglass-see-what-your-code-is-actually-doing/137020):
>
> Hi all, Over the past few years, we’ve been building runtime analysis tools for different languages and use cases, including Julia. Today, we would like to officially announce the release of our Julia profiling toolbox: CodeGlass for Julia. With CodeGlass we try to make profiling and finding issues as easy as possible. We do this by combining all the data in one central place and showing this in a visual and clicky way. CodeGlass collects everything that happens in your application in real-ti…

How does that compare to what you have in Lisp?

> [@farooqkz](#):
>
> So I wanted to ask how interactive development goes in Julia and how does it compare to the Lisp family?

Be sure to use Revise.jl, it’s extremely good, and allows by now redefining everything I believe (e.g. structs; the last annoyance until recently for interactive work; AI is still ignorant that recent improvement, and maybe others you may talk to, so old comparisons are too pessimistic about Julia), and Tamas Papp migrated from Lisp way before Revise got that good, or not even sure it existed back then.

From Papp in the community here (and others):

> **[Switching from Common Lisp to Julia](https://www.tamaspapp.eu/post/common-lisp-to-julia/)**

> **[From Common Lisp to Julia](https://web.archive.org/web/20230708055947/https://mfiano.net/posts/2022-09-04-from-common-lisp-to-julia/)**
>
> mfiano's blog

> **[From Common Lisp to Julia](https://news.ycombinator.com/item?id=32745318)**
>
> 183 points —
> 200 comments —
> thetwentyone —
> 1:23 AM - 7 Sep 2022

and response to it (might be outdated, I haven’t read it in a while): [not-common-lisp-to-julia.org · GitHub](https://gist.github.com/digikar99/24decb414ddfa15a220b27f6748165d7)

> **[Hello Julia: Looks like Python, feels like Lisp, runs like Fortran | Kaggle](https://www.kaggle.com/discussions/getting-started/309765)**
>
> Julia is a general-purpose interpreted language developed by a group at MIT, with numerical computing at the core of its design. It was first released in 201...

> [@Mason](#):
>
> in julia 1.14 you’ll be able to use [GitHub - MasonProtter/Lispy.jl · GitHub](https://github.com/MasonProtter/Lispy.jl) 😅 (but probably shouldn’t)

Seems like a successor to (that you can already use, but also likely should not, more of a demo?):

> ### LispSyntax.jl: A clojure-like lisp syntax for julia

In case any of this helps you interact with Lisp/Clojure or migrate (in stages):

> [@Using Julia from the JVM (Clojure)](https://discourse.julialang.org/t/using-julia-from-the-jvm-clojure/51052):
>
> Hey, I have been working on [libjulia-clj](https://github.com/cnuernber/libjulia-clj) and it is time to announce what little I have so far ;-). This is way that you can seamlessly call Julia from Clojure, a language hosted on the JVM. This allows you to use Julia for what it is good for and the JVM for what it is good for, thus sidestepping issues about which one is good at what. If you have never heard of Clojure, then I think there is plenty out there but here is a [new to Clojure document](https://github.com/clj-python/libpython-clj/blob/master/topics/new-to-clojure.md). I am a huge fan of Julia and need help build…

I’m not sure how good this is, just found it:

> **[Free Lisp to Julia Converter - AI Code Translation | CodeConvert AI](https://www.codeconvert.ai/lisp-to-julia-converter)**
>
> Instantly convert Lisp to Julia code with AI. Free, fast, and accurate code translation. 60+ languages supported, no signup required.

There are more e.g. [Free Clojure to Julia Converter - AI Code Translation | CodeConvert AI](https://www.codeconvert.ai/clojure-to-julia-converter) and [Free Julia to Clojure Converter - AI Code Translation | CodeConvert AI](https://www.codeconvert.ai/julia-to-clojure-converter) and others: [Julia to Clojure Converter - CodingFleet](https://codingfleet.com/code-converter/julia/clojure/) and outdated: [GitHub - vshesh/Sexpr.jl: julia \<3 clojure + macroexpansion · GitHub](https://github.com/vshesh/Sexpr.jl)

> **[GitHub - cnuernber/libjulia-clj: Julia bindings for Clojure -- Currently somewhat...](https://github.com/cnuernber/libjulia-clj)**
>
> Julia bindings for Clojure -- Currently somewhat unstable --

---

_[View the full topic](https://discourse.julialang.org/t/interactive-development-in-julia-compared-to-common-lisp/139494)._
