# Minimal Julia: What do you want in Julia, or not?

**URL:** <https://discourse.julialang.org/t/minimal-julia-what-do-you-want-in-julia-or-not/113569>\
**Category:** General Usage\
**Created:** [April 27, 2024, 5:01pm UTC](https://discourse.julialang.org/t/minimal-julia-what-do-you-want-in-julia-or-not/113569 "2024-04-27T17:01:55Z")\
**Posts on this page:** 19\
**Page:** 2

<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:** [February 25, 2025, 5:17pm UTC](https://discourse.julialang.org/t/minimal-julia-what-do-you-want-in-julia-or-not/113569/21 "2025-02-25T17:17:51Z")

</div>

My UPX experiment wasn’t too successful, if I recall, so I didn’t suggest using it for Julia (even better then compressing is just eliminating). I forget the details, they’re likely here in the thread. If it had helped, or if you I’m wrong, and you get it to work, then please make a PR. I don’t know about “strip”, maybe at least add a PR for that?

I’ve gotten rid of LinearAlgebra privately, it’s not to complex, but it needs NOT be a breaking change (same API), only e.g. multiplying matrices need to go to a slower matmul, until `using LinearAlgebra`. Moving to a new repo was I think only for code organization, and to have issues relating to it tracked there. Though might be first stop to get out of the sysimage.

I want to get rid of [Open]BLAS. And more e.g. MPFR I’m looking at now (there are better/faster alternatives, and none of BigFloat and BigInt need to be in Base, IMHO).

I’ve also found a much faster regex library (at least for some edge-cases, PCRE2, should also go).

---

<div class="post-metadata">

**Author:** ![mbauman](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/mbauman/32/31082_2.png) [@mbauman](https://discourse.julialang.org/u/mbauman)\
**Post date:** [February 25, 2025, 5:33pm UTC](https://discourse.julialang.org/t/minimal-julia-what-do-you-want-in-julia-or-not/113569/22 "2025-02-25T17:33:33Z")

</div>

That’s all highly speculative. One concrete path forward here is the upcoming v1.12’s [`--trim`](https://github.com/JuliaLang/julia/blob/release-1.12/NEWS.md#new-language-features).

---

<div class="post-metadata">

**Author:** ![gitboy16](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/gitboy16/32/24906_2.png) [@gitboy16](https://discourse.julialang.org/u/gitboy16)\
**Post date:** [February 25, 2025, 9:18pm UTC](https://discourse.julialang.org/t/minimal-julia-what-do-you-want-in-julia-or-not/113569/23 "2025-02-25T21:18:23Z")

</div>

I manage to remove LinearAlgebra from the sysimage. It reduces the size of the julia installation folder and seems to improve the startup time. LinearAlgebra can still be used as normal, so I am not sure why it has not been removed from the sysimage yet?

Regarding upx, it did not work for me on windows, however “strip” worked well on all the dll in the bin folder as well as the sysimage.dll and haven’t notice any negative effect. I was wondering if anyone else tested that?

In total I manage to reduce Julia 1.13 size down from 1.1G to 850M.

---

<div class="post-metadata">

**Author:** ![adienes](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/adienes/32/37459_2.png) [@adienes](https://discourse.julialang.org/u/adienes)\
**Post date:** [February 25, 2025, 9:48pm UTC](https://discourse.julialang.org/t/minimal-julia-what-do-you-want-in-julia-or-not/113569/24 "2025-02-25T21:48:13Z")

</div>

> [@gitboy16](#):
>
> so I am not sure why it has not been removed from the sysimage yet?

I think [Piracy in the StdLibs · Issue #30945 · JuliaLang/julia · GitHub](https://github.com/JuliaLang/julia/issues/30945#issuecomment-559545873) is a good tl;dr

---

<div class="post-metadata">

**Author:** ![joa-quim](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/joa-quim/32/227_2.png) [@joa-quim](https://discourse.julialang.org/u/joa-quim)\
**Post date:** [February 25, 2025, 11:25pm UTC](https://discourse.julialang.org/t/minimal-julia-what-do-you-want-in-julia-or-not/113569/25 "2025-02-25T23:25:20Z")

</div>

And if you delete all \*_\_T3QLl.dll_ from `share\julia\compiled\v1.13` like I mentioned in [Julia installation file sizes - #10 by gitboy16](https://discourse.julialang.org/t/julia-installation-file-sizes/119130/10), you shave another ~190 Mb. Also, apparently without any negative effect.

---

<div class="post-metadata">

**Author:** ![tecosaur](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/tecosaur/32/23206_2.png) [@tecosaur](https://discourse.julialang.org/u/tecosaur)\
**Post date:** [February 26, 2025, 3:03pm UTC](https://discourse.julialang.org/t/minimal-julia-what-do-you-want-in-julia-or-not/113569/26 "2025-02-26T15:03:12Z")

</div>

> [@Palli](#):
>
> [https://github.com/Genivia/RE-flex](https://github.com/Genivia/RE-flex) is a much faster regex engine, so if someone wants to experiment getting it to work, then at some point it could replace PCRE2, or as a first step add it through a package, then PCRE2 can be dropped by default (with a possibility to enable it for compatibility if needed).

This looks rather interesting, I wonder how close to PRCE-2 compatible it is…

---

<div class="post-metadata">

**Author:** ![mbauman](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/mbauman/32/31082_2.png) [@mbauman](https://discourse.julialang.org/u/mbauman)\
**Post date:** [February 27, 2025, 4:44pm UTC](https://discourse.julialang.org/t/minimal-julia-what-do-you-want-in-julia-or-not/113569/27 "2025-02-27T16:44:11Z")

</div>

11 posts were split to a new topic: [Why hasn’t LinearAlgebra been removed from the default sysimage?](https://discourse.julialang.org/t/why-hasnt-linearalgebra-been-removed-from-the-default-sysimage/126395)

---

<div class="post-metadata">

**Author:** ![jojob68](https://avatars.discourse-cdn.com/v4/letter/j/13edae/32.png) [@jojob68](https://discourse.julialang.org/u/jojob68)\
**Post date:** [February 27, 2025, 2:35am UTC](https://discourse.julialang.org/t/minimal-julia-what-do-you-want-in-julia-or-not/113569/30 "2025-02-27T02:35:24Z")

</div>

I am clearly not in the right league to comment on the technical aspects in this thread, but I feel like the perspective of an average (or below average!) user is missing. **Please** , do not turn Julia into another Python, where basic mathematical functions require importing additional packages (yes, this includes linear algebra in my view). For instance, I already find it odd and somewhat frustrating that I have to use `using Statistics` just to access the `mean` function. Maybe that’s just me, maybe not…

---

<div class="post-metadata">

**Author:** ![liuyxpp](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/liuyxpp/32/9870_2.png) [@liuyxpp](https://discourse.julialang.org/u/liuyxpp)\
**Post date:** [February 27, 2025, 5:05am UTC](https://discourse.julialang.org/t/minimal-julia-what-do-you-want-in-julia-or-not/113569/31 "2025-02-27T05:05:06Z")

</div>

> [@jojob68](#):
>
> For instance, I already find it odd and somewhat frustrating that I have to use `using Statistics` just to access the `mean` function. Maybe that’s just me, maybe not…

I echo this. I encounter this issue daily! Every time I start a new script/notebook, I forgot to import `Statistics` to just use `mean`! Not a big deal maybe, but really a bad experience!

I remember I have expressed my strong opposition to remove `Statistics` especially `mean` from Base here in discourse but in vein, sigh~

---

<div class="post-metadata">

**Author:** ![souma](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/souma/32/212836_2.png) [@souma](https://discourse.julialang.org/u/souma)\
**Post date:** [February 27, 2025, 5:16am UTC](https://discourse.julialang.org/t/minimal-julia-what-do-you-want-in-julia-or-not/113569/32 "2025-02-27T05:16:32Z")

</div>

I go back and forth on this all the time. Like, yes having an R like statistical standard library would make the transfer to Julia super easy. But also there is a lot to be said about trimming the fat and keeping statistics out of the environment unless they are needed. My main piece of advice on this front is “if your code is internal to you, and it bothers you, add Statistics to your startup file.” Outside of that its just one of those things that can be annoying.

Edit from 3/11/25: Although, as I’ve been working on `Dendrochronology.jl` I learned Julia is missing some fundamental time-series statistics that come in `r::stats`. I’m making a hacky solution rn, might try to integrate into `TimeSeries.jl` or `AutoRegressions.jl`

---

<div class="post-metadata">

**Author:** ![tecosaur](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/tecosaur/32/23206_2.png) [@tecosaur](https://discourse.julialang.org/u/tecosaur)\
**Post date:** [February 27, 2025, 5:25am UTC](https://discourse.julialang.org/t/minimal-julia-what-do-you-want-in-julia-or-not/113569/33 "2025-02-27T05:25:16Z")

</div>

Needing to import Statistics/StatsBase for stuff like `mean` or `countmap` used to trip me up a lot when I wanted to “just” do something simple in the REPL.

You can add this to your global environment/startup, but then it’s really easy to share code/packages that use one of the functions that you forgot isn’t part of the base language.

---

<div class="post-metadata">

**Author:** ![jakobnissen](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/jakobnissen/32/13477_2.png) [@jakobnissen](https://discourse.julialang.org/u/jakobnissen)\
**Post date:** [February 27, 2025, 8:04am UTC](https://discourse.julialang.org/t/minimal-julia-what-do-you-want-in-julia-or-not/113569/34 "2025-02-27T08:04:33Z")

</div>

When discussing what to keep in Base and what to have in packages, I think it’s important to realize how differently people use programming, even in science.  
There is a risk that Julia can cater too much to a niche audience, which causes Julia users to be the self-selected group who cares about those features, which in turn feeds the idea that “everyone wants this feature”. Right now, Julia very much caters to the “MATLAB” audience who works a lot with arrays of floats - and I happen to think that this self-selection process has already happened, and it’s detrimental to the language. You will notice that when Julia comes up in discussions outside the community: People talk about it as a domain-specific language for numerical computing and not a general purpose language.

For example, I don’t really care about multidimensional arrays and linear algebra at all. I find it totally unnecessary that we have QR factorization in the system image - I went to university and don’t even know what that means. I’m never going to use it. To me, that’s a great example of something niche that absolutely belongs in a package.

On the other hand, I think the functionality provided by the `StringViews`, `BufferedStreams` and `MemoryViews` packages are much more basic and really do belong in Base.

So who is right? None of us, of course. Both camps have this idea that the functions **we** happen to want to be in base is not that much and won’t bloat Julia (although BLAS in particular really does its share of bloating…). Whereas the truth is that Julia becomes _enourmous_ if it included all the “commonly used functionality” that people expect to be in the system image - because it’s all different stuff for different people.

The only viable approach is to have a much smaller Base without _any_ domain specific stuff. In my opinion, Base should only contain general “computer sciency” stuff like `Dict`s and `Vector`s and sorting and such, as well as some very basic abstract types/interfaces like `AbstractArray` and `AbstractString`. Using that, people can build everything else as a package.

---

<div class="post-metadata">

**Author:** ![yolhan\_mannes](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/yolhan_mannes/32/220485_2.png) [@yolhan\_mannes](https://discourse.julialang.org/u/yolhan_mannes)\
**Post date:** [February 27, 2025, 8:36am UTC](https://discourse.julialang.org/t/minimal-julia-what-do-you-want-in-julia-or-not/113569/35 "2025-02-27T08:36:35Z")

</div>

I agree with you, also, if someone want’s to make a close source science julia at some points (as matlab is for python/fortran ect) nothing stops them from doing so.  
And if someone wants all that in julia, they could still make a sysimage with their favorite packages and use that.  
I’m not sure we should get rid of multi-dim arrays though, they can be usefull for newcommers (avoid index mindblow in some cases) and they are particularly well design in julia.  
The question for \*(AbtractArray, AbtractArray) and \(AbtractArray, AbtractArray) is still hard but we could just make it a method error and a little tip to install LinearAlgebra (hardly breacking but not that annoying).  
Also, we could distinguish between package that are allowed to break type-privacy and others without having them in the sysimage, they would be more language-addon instead of packages.  
I’m not sure the language design is the only thing that makes julia kinda “niche” though but that’s another thread for another time.

---

<div class="post-metadata">

**Author:** ![jules](https://avatars.discourse-cdn.com/v4/letter/j/41988e/32.png) [@jules](https://discourse.julialang.org/u/jules)\
**Post date:** [February 27, 2025, 8:43am UTC](https://discourse.julialang.org/t/minimal-julia-what-do-you-want-in-julia-or-not/113569/36 "2025-02-27T08:43:29Z")

</div>

> [@yolhan\_mannes](#):
>
> I’m not sure we should get rid of multi-dim arrays though

I think this was not about removing multi-dimensional arrays, but rather the plethora of functions that work only on numerical tensors, but have no generic use otherwise.

Maybe the numerical focus was good in the beginning to have some clear differentiator, so it made sense to include all that stuff. But now that we have apps, binary compilation, more need for tooling, I think it becomes clear that being able to run Julia with the least bloat possible is important for the future development of the ecosystem.

---

<div class="post-metadata">

**Author:** ![yolhan\_mannes](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/yolhan_mannes/32/220485_2.png) [@yolhan\_mannes](https://discourse.julialang.org/u/yolhan_mannes)\
**Post date:** [February 27, 2025, 8:45am UTC](https://discourse.julialang.org/t/minimal-julia-what-do-you-want-in-julia-or-not/113569/37 "2025-02-27T08:45:55Z")

</div>

yes that shouldn’t be inside julia sysimage at all I agree, especially with sysimage now, but allowing non-type-private packages in really specific cases shouldn’t be that scary, should it ? Also, having method error on \* for AbstractArray wouldn’t be a problem at all for the same reason +(String,String) is not a problem right now.

---

<div class="post-metadata">

**Author:** ![foobar\_lv2](https://avatars.discourse-cdn.com/v4/letter/f/ee59a6/32.png) [@foobar\_lv2](https://discourse.julialang.org/u/foobar_lv2)\
**Post date:** [February 27, 2025, 9:28am UTC](https://discourse.julialang.org/t/minimal-julia-what-do-you-want-in-julia-or-not/113569/38 "2025-02-27T09:28:26Z")

</div>

An example I like a lot is python / `sagemath`. There are basically two modes you can run in:

1. In “sage”-mode, which means that you are basically running “sage”-code: A dialect of python designed specifically for the stuff that sage is good in. Of course you don’t need explicit imports for linear algebra!
2. In “python”-mode, which basically gives you standard python, but you can access sage-specific functionality “like a library”, i,e. by importing and using a somewhat pythonic API.

The “python”-mode exists for technical reasons: Ideally sage would be usable as a normal library/package. But there is some necessary runtime support, i.e. the sage package only works in the sage fork of the cpython runtime.

That way, you get to eat your cake and have it.

A julia analogue would be: Ruthlessly excise code from base, and have a meta-package, maintained and blessed by the core team, that re-exports relevant functionality. Then one could get the “batteries included” experience by a simple `using Batteries`.

In such an approach, it is essential that there really is one and only one `Batteries` meta-package that is documented and blessed and tested and owned by the core julia org.

Community owned competing batteries-like packages are not inherently a problem. However, the people who want the matlab experience must not be bothered to make a choice on their batteries-like metapackage, or to figure out the necessary imports for all functionality they need. A simple `using Batteries` is pretty much the max of inconvenience one can force on them.

---

<div class="post-metadata">

**Author:** ![gitboy16](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/gitboy16/32/24906_2.png) [@gitboy16](https://discourse.julialang.org/u/gitboy16)\
**Post date:** [February 27, 2025, 10:48am UTC](https://discourse.julialang.org/t/minimal-julia-what-do-you-want-in-julia-or-not/113569/39 "2025-02-27T10:48:21Z")

</div>

That can be an interesting option.  
A potential benefit of trimming down Julia is, it will maybe reduce resources (time and money) on CI/CD, developer’s time?  
I am ignorant on the topic but probably breaking down these things (moving documentation and testing to their own repo) can also save resource? For example is it really necessary to run tests and Julia build suite when a typo is corrected in the documentation?  
I am wondering what are the core developer’s views on the topics. Whether it is a topic they have in mind? And whether Julia growing installation size is not really a cause for concern?

---

<div class="post-metadata">

**Author:** ![adienes](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/adienes/32/37459_2.png) [@adienes](https://discourse.julialang.org/u/adienes)\
**Post date:** [February 27, 2025, 2:36pm UTC](https://discourse.julialang.org/t/minimal-julia-what-do-you-want-in-julia-or-not/113569/41 "2025-02-27T14:36:06Z")

</div>

> [@jakobnissen](#):
>
> is to have a much smaller Base without _any_ domain specific stuff.

I think it’s possible also to “have a much smaller Base” _as well_ as having a larger sysimage option; imagine `juliaup add release --bundle=linalg` vs `--bundle=lightweight`

---

<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:** [February 27, 2025, 4:52pm UTC](https://discourse.julialang.org/t/minimal-julia-what-do-you-want-in-julia-or-not/113569/42 "2025-02-27T16:52:34Z")

</div>

FYI: “Type piracy” is an almost 10 year old term (in Julia-land, and not known to me either before that, since it’s I believe Julia-specific, at least not a common CS term):

[https://groups.google.com/g/julia-users/c/gGbaUVETvwQ](https://groups.google.com/g/julia-users/c/gGbaUVETvwQ)

LinearAlgebra has the “excision” label (there):

> <https://github.com/JuliaLang/LinearAlgebra.jl/issues/1027>
>
> I was thinking about JuliaLang/julia#51432 this morning and I was curious how ba…d it would be for LinearAlgebra.
> 
> Using:
> \`\`\`
> import LinearAlgebra
> 
> function allinbase(T)
> T = Base.unwrap\_unionall(T)
> if T isa Union
> return allinbase(T.a) && allinbase(T.b)
> end
> return T.name.module == Base || T.name.module == Core
> end
> 
> for name in names(Base)
> obj = getglobal(Base, name)
> if obj isa Function
> candidates = methods(obj, LinearAlgebra)
> for candidate in candidates
> sig = Base.tuple\_type\_tail(candidate.sig)
> allInBase = true
> while sig !== Tuple{}
> T = Base.tuple\_type\_head(sig)
> sig = Base.tuple\_type\_tail(sig)
> allInBase &= allinbase(T)
> allInBase || break 
> end
> if allInBase
> println(candidate)
> end
> end
> end
> end
> \`\`\`
> 
> In 1.10-beta.2 we have the following candidates:
> 
> \`\`\`
> adjoint(B::Union{BitMatrix, BitVector}) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/bitarray.jl:237
> adjoint(a::AbstractArray) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/transpose.jl:3
> \*(A::AbstractMatrix, B::AbstractMatrix, C::AbstractMatrix, D::AbstractMatrix) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/matmul.jl:1229
> \*(A::AbstractMatrix, B::AbstractMatrix, C::AbstractMatrix, x::AbstractVector) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/matmul.jl:1221
> \*(A::AbstractMatrix, B::AbstractMatrix, x::AbstractVector) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/matmul.jl:1144
> \*(A::AbstractMatrix, B::AbstractMatrix, C::AbstractMatrix) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/matmul.jl:1160
> \*(a::AbstractVector, B::AbstractMatrix) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/matmul.jl:63
> \*(A::AbstractMatrix{T}, x::AbstractVector{S}) where {T, S} @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/matmul.jl:55
> \*(A::AbstractMatrix, B::AbstractMatrix) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/matmul.jl:104
> \\(a::AbstractVector, b::AbstractArray) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/generic.jl:1129
> ^(::Irrational{:ℯ}, A::AbstractMatrix) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/dense.jl:645
> acos(A::AbstractMatrix) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/dense.jl:1135
> acosh(A::AbstractMatrix) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/dense.jl:1215
> acot(A::AbstractMatrix{T}) where T @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/dense.jl:1289
> acoth(A::AbstractMatrix{T}) where T @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/dense.jl:1292
> acsc(A::AbstractMatrix{T}) where T @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/dense.jl:1289
> acsch(A::AbstractMatrix{T}) where T @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/dense.jl:1292
> adjoint(B::Union{BitMatrix, BitVector}) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/bitarray.jl:237
> adjoint(a::AbstractArray) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/transpose.jl:3
> asec(A::AbstractMatrix{T}) where T @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/dense.jl:1289
> asech(A::AbstractMatrix{T}) where T @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/dense.jl:1292
> asin(A::AbstractMatrix) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/dense.jl:1166
> asinh(A::AbstractMatrix) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/dense.jl:1234
> atan(A::AbstractMatrix) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/dense.jl:1197
> atanh(A::AbstractMatrix) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/dense.jl:1252
> cis(A::AbstractMatrix{\<:Union{Float32, Float64, Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Complex{\<:Union{Float32, Float64, Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8}}, Rational{\<:Union{Float32, Float64, Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8}}}}) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/dense.jl:616
> cis(A::AbstractMatrix) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/dense.jl:615
> convert(::Type{T}, A::AbstractMatrix) where T\<:Diagonal @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/diagonal.jl:100
> convert(::Type{T}, m::AbstractMatrix) where T\<:Bidiagonal @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/bidiag.jl:220
> copyto!(dest::Array{T}, rdest::AbstractRange{Ti}, src::Array{T}, rsrc::AbstractRange{Ti}) where {T\<:Union{Float32, Float64, ComplexF64, ComplexF32}, Ti\<:Integer} @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/blas.jl:2121
> cos(A::AbstractMatrix{\<:Complex}) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/dense.jl:946
> cos(A::AbstractMatrix{\<:Real}) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/dense.jl:939
> cosh(A::AbstractMatrix) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/dense.jl:1072
> cot(A::AbstractMatrix{T}) where T @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/dense.jl:1272
> coth(A::AbstractMatrix{T}) where T @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/dense.jl:1277
> csc(A::AbstractMatrix{T}) where T @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/dense.jl:1272
> csch(A::AbstractMatrix{T}) where T @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/dense.jl:1277
> eltype(::Type{\<:LinearAlgebra.AbstractQ{T}}) where T @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/abstractq.jl:10
> eltype(::Type{\<:LinearAlgebra.Factorization{T}}) where T @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/factorization.jl:40
> eltype(::Type{LinearAlgebra.UniformScaling{T}}) where T @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/uniformscaling.jl:86
> exp(A::AbstractMatrix) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/dense.jl:594
> inv(A::AbstractMatrix{T}) where T @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/generic.jl:1048
> isapprox(x::AbstractArray, y::AbstractArray; atol, rtol, nans, norm) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/generic.jl:1785
> isone(A::AbstractMatrix) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/dense.jl:16
> kron(a::BitMatrix, b::BitMatrix) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/bitarray.jl:131
> kron(a::BitVector, b::BitVector) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/bitarray.jl:107
> kron(a::AbstractVector{T}, b::AbstractVector{S}) where {T, S} @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/dense.jl:469
> kron!(R::BitMatrix, a::BitMatrix, b::BitMatrix) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/bitarray.jl:114
> kron!(R::BitVector, a::BitVector, b::BitVector) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/bitarray.jl:95
> kron!(c::AbstractVector, a::AbstractVector, b::AbstractVector) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/dense.jl:370
> log(A::AbstractMatrix) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/dense.jl:798
> one(::Type{LinearAlgebra.UniformScaling{T}}) where T @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/uniformscaling.jl:130
> oneunit(::Type{LinearAlgebra.UniformScaling{T}}) where T @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/uniformscaling.jl:132
> promote\_rule(::Type{Matrix{T}}, ::Type{\<:LinearAlgebra.Bidiagonal{S, V} where V\<:AbstractVector{S}}) where {T, S} @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/bidiag.jl:202
> promote\_rule(::Type{\<:AbstractMatrix{T}}, ::Type{\<:LinearAlgebra.AbstractQ{T}}) where T @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/abstractq.jl:21
> promote\_rule(A::Type{\<:LinearAlgebra.Diagonal{\<:Any, V}}, B::Type{\<:LinearAlgebra.Diagonal{\<:Any, W}}) where {V, W} @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/diagonal.jl:17
> promote\_rule(::Type{\<:LinearAlgebra.Tridiagonal}, ::Type{\<:LinearAlgebra.Bidiagonal}) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/bidiag.jl:215
> promote\_rule(::Type{\<:LinearAlgebra.Tridiagonal{T, V} where V\<:AbstractVector{T}}, ::Type{\<:LinearAlgebra.Bidiagonal{S, V} where V\<:AbstractVector{S}}) where {T, S} @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/bidiag.jl:213
> sec(A::AbstractMatrix{T}) where T @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/dense.jl:1272
> sech(A::AbstractMatrix{T}) where T @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/dense.jl:1277
> sin(A::AbstractMatrix{\<:Complex}) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/dense.jl:979
> sin(A::AbstractMatrix{\<:Real}) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/dense.jl:972
> sincos(A::AbstractMatrix{\<:Real}) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/dense.jl:1013
> sincos(A::AbstractMatrix{\<:Complex}) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/dense.jl:1024
> sinh(A::AbstractMatrix) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/dense.jl:1086
> sqrt(A::AbstractMatrix{T}) where T\<:Union{Real, Complex} @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/dense.jl:877
> tan(A::AbstractMatrix) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/dense.jl:1058
> tanh(A::AbstractMatrix) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/dense.jl:1100
> transpose(B::Union{BitMatrix, BitVector}) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/bitarray.jl:238
> transpose(a::AbstractArray) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/transpose.jl:4
> zero(::Type{LinearAlgebra.UniformScaling{T}}) where T @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/uniformscaling.jl:134
> sqrt(A::AbstractMatrix{T}) where T\<:Union{Real, Complex} @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/dense.jl:877
> isapprox(x::AbstractArray, y::AbstractArray; atol, rtol, nans, norm) @ LinearAlgebra ~/.julia/juliaup/julia-1.10.0-beta2+0.x64.linux.gnu/share/julia/stdlib/v1.10/LinearAlgebra/src/generic.jl:1785
> \`\`\`
> 
> This is surprisingly managable and even include's some false-positives. E.g. \`promote\_rule\`/\`convert\`.

At least to discuss how, or how difficult. Many more have that label at JuliaLang, but since LinearAlgebra already has its own repo (recently), it’s now the only issue there with that label.

It’s easy to get rid of it in a braking change, and that what would happen because of the type piracy, if just dropped in a naive way. It’s also easy to keep it fully non-breaking (I’ll not repeat myself here, I see others have recently with very similar ideas).

FYI: Other examples:

> <https://github.com/JuliaLang/julia/pull/56875>
>
> This pr replaced #42299
> 
> On Windows, we use \`libmingwex\` to provide math funct…ions which are not implemented by \`msvcrt\` (Old Microsoft Libm).
> From \`libmingwex\`: \`ldexp, log2l, exp2l, powi\`
> 
> Note: We are using a special toolchain \`i686-12.2.0-release-posix-sjlj\` from \[niXman/mingw-builds-binaries\](https://github.com/niXman/mingw-builds-binaries/) for \`i686-windows\`.

Note, Julia has already rewritten all of libm from C into Julia, so that will have no change. As I recall it’s only 32-bit Windows holding back for obscure reasons.

HOWEVER, I think we might want to go back to a C library libm. Off-topic for here, but only \*, /, +, - and sqrt are correctly rounded in accordance with IEEE. IEEE doesn’t demand more, for arbitrary math functions, since it was thought impossible to do (and fast), but a recent libm did so. I believe this one for Float32:

> **[RLIBM-32: High Performance Correctly Rounded Math Libraries for 32-bit...](https://arxiv.org/abs/2104.04043)**
>
> This paper proposes a set of techniques to develop correctly rounded math libraries for 32-bit float and posit types. It enhances our RLibm approach that frames the problem of generating correctly rounded libraries as a linear programming problem in...

and I’m just now seeing something for Float64:  
[https://www.worldscientific.com/doi/10.1142/S0218194023500675](https://www.worldscientific.com/doi/10.1142/S0218194023500675)

There’s also:

> **[GitHub - JuliaIntervals/CRlibm.jl: Correctly-rounded mathematical functions](https://github.com/JuliaIntervals/CRlibm.jl)**
>
> Correctly-rounded mathematical functions

We may think we want `sqrt` available, it’s a common function. But by defining it in Julia, it’s generic, and it also apples to a square root of a matrix (not element-wise, that’s yet another operation), and looking at the code for it, it brings in a lot more obscure (to me) code. I’ve never had to do it, at best square a matrix or do integer power of. I’m not sure how common roots or arbitrary powers of a matrix are… [And trivia, one of the quantum gates are square root of NOT.]

> **[2.5 The square root of NOT | Introduction to Quantum Information Science](https://qubit.guide/2.5-the-square-root-of-not)**
>
> An introductory textbook on quantum information science.

> Let us call the resulting logic gate the square root of NOT […]  
> It may seem reasonable to argue that since there is no such operation in logic, […] But it does exist!

> <https://github.com/JuliaLang/julia/issues/38300>
>
> This is a Julia 2.0 issue and definitely cannot be done in Julia 1.x. It would b…e good to move Regex functionality into a stdlib. This would allow not including PCRE (or whatever regex implementation we're using at that point) in an application image if regexes aren't used at all in the program.

[Previous page](https://discourse.julialang.org/t/minimal-julia-what-do-you-want-in-julia-or-not/113569.md?page=1)