# Did Modular just reinvent Julia?

**URL:** <https://discourse.julialang.org/t/did-modular-just-reinvent-julia/98214>\
**Category:** Offtopic\
**Tags:** mojo\
**Created:** [May 2, 2023, 5:22pm UTC](https://discourse.julialang.org/t/did-modular-just-reinvent-julia/98214 "2023-05-02T17:22:20Z")\
**Posts on this page:** 1\
**Showing post:** 167

<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:** [May 18, 2023, 1:31am UTC](https://discourse.julialang.org/t/did-modular-just-reinvent-julia/98214/167 "2023-05-18T01:31:20Z")

</div>

Mojo avoids mistakes of C++, but does it avoid Rust’s “billion dollar mistake”? See below.

> [@FHell](#):
>
> Mojo seems almost diametrically opposed to Julia to me.

Not to me (and I see I’m not the only one opposing). Isn’t it static, i.e. like the Julia subset where you type all your functions? And since that’s not needed in Julia, then Julia is a superset of Mojo capabilities? _Except_ Julia has GC (by default), and Mojo has a borrow checker (could such be added as an option-in for Julia?). The safety of Rust is that the borrow checker **isn’t** opt-in (important for concurrency), but since Mojo is like two languages in one, it’s opt-in there (only on for new _Mojo_ code, not the legacy Python code).

However, Julia is as safe as Python; as safe as Rust actually for single-threaded code(?), with out the mental overhead of Rust.

See here on Rust’s mistake, and Rust’s glidesort:

> [@Why \`Mojo\` can be so fast?](https://discourse.julialang.org/t/why-mojo-can-be-so-fast/98458/15):
>
> You write in a functional style (which is good). There are only two (one? zero?) inherent (i.e. after you’ve followed Julia’s performance section of the manual) performance limitations I know of in Julia. It’s not really hard to make a language fast, just hard to make it fast and dynamic, what Julia did, so far only language. Mojo feels like two languages in one, the new static, plus the old legacy dynamic Python syntax/semantics. C++ (not just its standard library API) and Rust have performanc…

I don’t believe Mojo reinvented Julia, i.e. Julia is still better, at least in most ways. Julia solved the two-language problem, while Mojo didn’t yet, it’s only on its roadmap. It only solved it with CPython making legacy Python code work, and PythonCall.jl also does that, with same semantics (only the syntax is different for the legacy (Python) code).

---

_[View the full topic](https://discourse.julialang.org/t/did-modular-just-reinvent-julia/98214)._