# Is anyone using 32-bit Julia on Windows?

**URL:** <https://discourse.julialang.org/t/is-anyone-using-32-bit-julia-on-windows/89525>\
**Category:** General Usage\
**Created:** [October 30, 2022, 2:49pm UTC](https://discourse.julialang.org/t/is-anyone-using-32-bit-julia-on-windows/89525 "2022-10-30T14:49:05Z")\
**Posts on this page:** 20\
**Page:** 1

<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:** [October 30, 2022, 2:49pm UTC](https://discourse.julialang.org/t/is-anyone-using-32-bit-julia-on-windows/89525/1 "2022-10-30T14:49:05Z")

</div>

I don’t see much reason to keep that dying platform around, and think it would help it it were retired (but not (yet) 32-bit Linux).

I see work on Julia seemingly blocked on it (getting rid of libm, otherwise done, or almost done).

And I’m not sure, ~~maybe it’s slowing down very important work like this:~~

I’m at least reading through (32-bit) CI logs that maybe should just be dropped (it also takes resources to generate them, you can easily wait 5 hours for them generated, and 6 hours for the awesome PkgEval, which would be “sequentially, 26 days” of work, so seemingly using 104 CPUs so we don’t want to do useless work). Would you rather want faster development of Julia or keep 32-bit?

Likely 32-bit Windows would still work, maybe not perfectly(?), and just no longer a tier 2 platform.

Note Windows 11 doesn’t support 32-bit CPUs (though does support 32- and 6-bit (Julia) programs).

Only Windows 8.1 (and 10) support 32-bit CPUs, already out of mainstream support, and extended support only until January 10, 2023. For Windows 10 “Mainstream support for all editions except “[LTSB/LTSC](https://en.wikipedia.org/wiki/LTSC)” variants ended on October 13, 2020 and extended support continues until October 14, 2025”. The dropped support applies to 64-bit too, and maybe it’s actually sooner for 32-bit?

Windows Server no longer supports 32-bit, Windows Server 2008 was the last version to do it. Though you can pay extra to keep it around (and “Azure Virtual Desktop” isn’t relevant to Julia): “ESU (Extended Security Updates) program (free for [Azure Virtual Desktop](https://en.wikipedia.org/wiki/Azure_Virtual_Desktop) users).[[5]](https://en.wikipedia.org/wiki/Windows_Server_2008#cite_note-tfosmark-2-5) This program allows volume license customers to purchase, in yearly installments, security updates for the operating system through at most January 10, 2023 (January 9, 2024 for [Azure](https://en.wikipedia.org/wiki/Microsoft_Azure) customers)”.

---

<div class="post-metadata">

**Author:** ![dlakelan](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/dlakelan/32/8491_2.png) [@dlakelan](https://discourse.julialang.org/u/dlakelan)\
**Post date:** [October 30, 2022, 10:24pm UTC](https://discourse.julialang.org/t/is-anyone-using-32-bit-julia-on-windows/89525/2 "2022-10-30T22:24:48Z")

</div>

I know you are talking about windows specifically but just want to point out that a lot of small cheap SBCs such as Raspberry Pi are still using 32 bit so the Linux version makes sense.

---

<div class="post-metadata">

**Author:** ![woclass](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/woclass/32/212699_2.png) [@woclass](https://discourse.julialang.org/u/woclass)\
**Post date:** [October 31, 2022, 3:06am UTC](https://discourse.julialang.org/t/is-anyone-using-32-bit-julia-on-windows/89525/3 "2022-10-31T03:06:31Z")

</div>

Build and test on 32 bit is really slow.

MSYS2 v.s. Cygwin build and test time

| Shell env | MSYS2 | Cygwin | MSYS2 | Cygwin |
| --- | --- | --- | --- | --- |
| toolchain | mingw64 | mingw64 | mingw32 | mingw32 |
| arch | x86\_64 | x86\_64 | x86 | x86 |
| Build | . | . | . | . |
| Sysimage built/s | 55.9 | 55.9 | 87.7 | 85.9 |
| Precompilation/s | 148.9 | 147.1 | 691.6 | 672.4 |
| Pre–Generation | 115.4 | 113.9 | 440.5 | 433.2 |
| Pre–Execution | 33.5 | 33.2 | 251.1 | 239.2 |
| Output sysimage/s | 150.6 | 149.1 | 156.6 | 155.7 |
| Test | . | . | . | . |
| Overall | 27m02.3s | 26m27.7s | 70m14.0s | 72m15.3s |
| LinearAlgebra/triangular | 10m58.9s | 10m52.0s | 14m35.1s | 14m07.8s |
| LinearAlgebra/addmul | 9m19.5s | 9m07.8s | 12m05.8s | 6m28.2s |
| intfuncs | 10.1s | 10.0s | 12m05.4s | 12m43.9s |
| bitarray | 3m40.3s | 3m42.3s | 23m17.4s | 24m01.3s |
| Profile | 30.8s | 32.1s | 34m35.5s | 38m22.2s |

> <https://github.com/JuliaLang/julia/pull/46140>
>
> Close #46139 
> 
> \- \[x\] build with MINGW64 + pre-build deps
> - \[x\] run test loc…ally
> \- \[x\] build with MINGW32 + pre-build deps
> - \[x\] run test locally
> \- \[x\] build with cygwin
> \- \[x\] add docs
> 
> MSYS2 v.s. Cygwin build and test time
> 
> | Shell env | MSYS2 | Cygwin | MSYS2 | Cygwin |
> |--------------------------|---------:|---------:|---------:|---------:|
> | toolchain | mingw64 | mingw64 | mingw32 | mingw32 |
> | arch | x86\_64 | x86\_64 | x86 | x86 |
> | Build | . | . | . | . |
> | Sysimage built/s | 55.9 | 55.9 | 87.7 | 85.9 |
> | Precompilation/s | 148.9 | 147.1 | 691.6 | 672.4 |
> | Pre--Generation | 115.4 | 113.9 | 440.5 | 433.2 |
> | Pre--Execution | 33.5 | 33.2 | 251.1 | 239.2 |
> | Output sysimage/s | 150.6 | 149.1 | 156.6 | 155.7 |
> | Test | . | . | . | . |
> | Overall | 27m02.3s | 26m27.7s | 70m14.0s | 72m15.3s |
> | LinearAlgebra/triangular | 10m58.9s | 10m52.0s | 14m35.1s | 14m07.8s |
> | LinearAlgebra/addmul | 9m19.5s | 9m07.8s | 12m05.8s | 6m28.2s |
> | intfuncs | 10.1s | 10.0s | 12m05.4s | 12m43.9s |
> | bitarray | 3m40.3s | 3m42.3s | 23m17.4s | 24m01.3s |
> | Profile | 30.8s | 32.1s | 34m35.5s | 38m22.2s |
> 
> raw test output: https://gist.github.com/inkydragon/548d2eb99955c758b6c6b907b03aeaa8
> 
> \<details\>
> \<summary\>mingw64 test log\</summary\>
> 
> 
> \### build
> \`\`\`
> Sysimage built. Summary:
> Base ──────── 26.613768 seconds 47.5633%
> Stdlibs ───── 29.338653 seconds 52.4332%
> Total ─────── 55.954380 seconds
> make\[1\]: Leaving directory '/v/julia/julia-mingw64'
> make\[1\]: Entering directory '/v/julia/julia-mingw64'
> JULIA julia-mingw64/usr/lib/julia/sys-o.a
> Generating REPL precompile statements... 40/40
> Executing precompile statements... 2028/2061
> Precompilation complete. Summary:
> Generation ── 115.457198 seconds 77.5291%
> Execution ─── 33.463985 seconds 22.4709%
> Total ─────── 148.921183 seconds
> Outputting sysimage file...
> Output ────── 150.625233 seconds
> \`\`\`
> 
> \### test
> 
> version
> \`\`\`
> julia\> versioninfo()
> Julia Version 1.9.0-DEV.1040
> Commit c7ff32668c\* (2022-07-28 07:53 UTC)
> Platform Info:
> OS: Windows (x86\_64-w64-mingw32)
> CPU: 6 × Intel(R) Core(TM) i5-9400F CPU @ 2.90GHz
> WORD\_SIZE: 64
> LIBM: libopenlibm
> LLVM: libLLVM-14.0.5 (ORCJIT, skylake)
> Threads: 1 on 6 virtual cores
> \`\`\`
> 
> \- Downloads: Fail x4
> 
> \`\`\`
> Test Summary: | Pass Fail Broken Total Time
> Overall | 40433277 4 352668 40785949 27m02.3s
> LinearAlgebra/schur | 496 496 45.5s
> LinearAlgebra/eigen | 512 512 1m13.2s
> LinearAlgebra/qr | 4705 4705 2m14.8s
> LinearAlgebra/bunchkaufman | 5688 5688 39.7s
> LinearAlgebra/lapack | 802 802 37.0s
> LinearAlgebra/svd | 566 566 1m08.1s
> LinearAlgebra/special | 2942 2942 4m16.0s
> LinearAlgebra/tridiag | 1541 1541 1m01.1s
> LinearAlgebra/dense | 8475 8475 5m46.5s
> LinearAlgebra/cholesky | 2509 2509 1m56.7s
> LinearAlgebra/matmul | 1486 1486 6m39.2s
> LinearAlgebra/bidiag | 4736 4736 3m49.1s
> LinearAlgebra/generic | 630 630 49.1s
> LinearAlgebra/lu | 1368 1368 2m00.0s
> LinearAlgebra/uniformscaling | 446 446 1m17.7s
> LinearAlgebra/lq | 2938 2938 1m08.1s
> LinearAlgebra/hessenberg | 631 631 1m08.4s
> LinearAlgebra/pinv | 500 500 9.6s
> LinearAlgebra/adjtrans | 347 347 30.8s
> LinearAlgebra/givens | 1847 1847 5.5s
> LinearAlgebra/blas | 1629 1629 1m07.2s
> LinearAlgebra/ldlt | 8 8 1.0s
> LinearAlgebra/factorization | 80 16 96 4.5s
> ambiguous | 104 2 106 7.6s
> LinearAlgebra/diagonal | 2877 2877 5m48.1s
> compiler/effects | 35 35 0.7s
> compiler/validation | 28 28 0.4s
> LinearAlgebra/structuredbroadcast | 670 670 59.1s
> compiler/inference | 1200 2 1202 16.0s
> compiler/irpasses | 139 4 143 4.4s
> compiler/ssair | 69 69 5.7s
> compiler/contextual | 12 12 2.9s
> compiler/inline | 226 1 227 5.9s
> compiler/AbstractInterpreter | 12 12 8.0s
> compiler/codegen | 173 173 17.6s
> compiler/EscapeAnalysis/interprocedural | 32 4 36 8.9s
> compiler/EscapeAnalysis/local | 347 21 368 15.5s
> strings/search | 876 876 8.0s
> strings/basic | 87693 87693 13.5s
> strings/io | 12764 12764 4.1s
> strings/types | 2302691 2302691 3.8s
> unicode/utf8 | 19 19 0.1s
> strings/util | 1147 1147 13.8s
> worlds | 88 88 2.5s
> LinearAlgebra/triangular | 37908 37908 10m58.9s
> keywordargs | 151 151 1.9s
> atomics | 3448 3448 19.0s
> subtype | 337681 19 337700 16.4s
> LinearAlgebra/symmetric | 2847 2847 5m19.7s
> triplequote | 29 29 0.0s
> char | 1639 1639 3.4s
> intrinsics | 309 309 3.1s
> hashing | 12519 12519 20.5s
> iobuffer | 209 209 1.7s
> staged | 65 65 3.4s
> dict | 144426 144426 29.9s
> numbers | 1584712 1 1584713 1m23.5s
> core | 8445940 3 8445943 1m34.4s
> tuple | 666 666 10.3s
> offsetarray | 502 3 505 47.6s
> reduce | 8591 8591 27.4s
> intfuncs | 227881 227881 10.1s
> simdloop | 240 240 2.3s
> vecelement | 678 678 7.8s
> rational | 98695 2 98697 33.2s
> subarray | 318323 318323 3m30.6s
> copy | 544 544 3.4s
> reducedim | 1225 6 1231 1m30.1s
> fastmath | 946 946 6.8s
> functional | 98 98 7.2s
> arrayops | 2089 6 2095 2m18.4s
> operators | 13052 13052 14.4s
> math | 1910225 1910225 41.9s
> path | 1051 12 1063 1.3s
> ordering | 37 37 3.5s
> parse | 16098 16098 5.4s
> abstractarray | 55298 24795 80093 2m23.4s
> gmp | 2444 2444 15.3s
> iterators | 86614 86614 1m56.5s
> spawn | 236 4 240 30.0s
> backtrace | 39 1 40 4.8s
> exceptions | 70 70 1.6s
> file | 767 767 12.8s
> bitarray | 914220 914220 3m40.3s
> version | 2453 2453 1.1s
> ccall | 5395 5395 2m50.7s
> namedtuple | 216 216 3.2s
> mpfr | 1137 1 1138 20.0s
> complex | 8480 2 8482 12.8s
> floatapprox | 49 49 0.8s
> reflection | 427 427 5.6s
> regex | 142 142 3.6s
> sorting | 24209 9 24218 2m52.9s
> float16 | 762093 762093 7.5s
> sysinfo | 4 4 0.2s
> env | 177 177 0.8s
> LinearAlgebra/addmul | 5832 5832 9m19.5s
> rounding | 150016 150016 6.1s
> combinatorics | 170 170 8.9s
> mod2pi | 80 80 0.6s
> euler | 12 12 1.5s
> client | 5 5 2.3s
> errorshow | 246 246 7.4s
> show | 128892 8 128900 37.1s
> goto | 19 19 0.1s
> broadcast | 525 525 1m35.7s
> llvmcall2 | 20 20 0.1s
> llvmcall | 19 19 0.5s
> some | 72 72 1.4s
> ryu | 31215 31215 2.0s
> meta | 69 69 0.9s
> stacktraces | 48 48 1.9s
> read | 3810 3810 2m09.8s
> docs | 239 239 4.9s
> sets | 3643 1 3644 34.7s
> enums | 100 100 3.9s
> binaryplatforms | 341 341 8.0s
> atexit | 40 40 8.3s
> interpreter | 3 3 1.9s
> int | 736188 736188 9.3s
> ranges | 12110619 327682 12438301 1m04.5s
> bitset | 195 195 3.2s
> checked | 1239 1239 10.1s
> error | 33 33 1.5s
> boundscheck | None 9.0s
> osutils | 57 57 0.1s
> cartesian | 349 3 352 9.7s
> iostream | 50 50 1.9s
> secretbuffer | 30 30 1.8s
> specificity | 175 175 0.2s
> misc | 1282200 1282200 50.3s
> loading | 151329 151329 5m15.7s
> corelogging | 235 235 4.4s
> channels | 256 256 28.2s
> reinterpretarray | 421 421 22.8s
> smallarrayshrink | 36 36 0.6s
> syntax | 1659 1 1660 12.5s
> opaque\_closure | 66 1 67 0.5s
> filesystem | 6 6 0.3s
> SparseArrays/ambiguous | 1 1 5.7s
> download | None 6.1s
> asyncmap | 307 307 12.7s
> missing | 574 1 575 20.5s
> SparseArrays/sparsematrix\_ops | 415 415 52.3s
> floatfuncs | 232 232 2m27.2s
> SparseArrays/linalg | 1814 1814 1m42.3s
> SparseArrays/issues | 326 326 1m24.4s
> SparseArrays/linalg\_solvers | 364 364 28.0s
> SparseArrays/cholmod | 611 611 33.9s
> cmdlineargs | 274 5 279 3m57.5s
> SparseArrays/spqr | 91 91 7.6s
> SparseArrays/higherorderfns | 7145 1 7146 3m03.2s
> Dates/accessors | 7723858 7723858 7.0s
> Dates/query | 1004 1004 1.3s
> Dates/adjusters | 3149 3149 7.6s
> SparseArrays/umfpack | 288 288 1m11.4s
> Dates/periods | 953 953 22.1s
> LibGit2/libgit2 | 595 595 33.5s
> Dates/types | 232 232 1.8s
> Dates/rounding | 315 315 2.9s
> Dates/ranges | 350639 350639 20.9s
> Dates/conversions | 160 160 1.2s
> ArgTools | 180 180 6.8s
> Dates/arithmetic | 385 385 10.2s
> Base64 | 2031 2031 2.8s
> CompilerSupportLibraries\_jll | 4 4 0.0s
> CRC32c | 664 664 0.8s
> Dates/io | 332 332 15.2s
> DelimitedFiles | 89 89 6.0s
> Future | None 0.0s
> GMP\_jll | 1 1 0.0s
> Artifacts | 1452 1452 16.6s
> LLVMLibUnwind\_jll | None 0.0s
> LazyArtifacts | 4 4 5.6s
> LibCURL | 6 6 2.7s
> LibCURL\_jll | 1 1 0.0s
> LibGit2\_jll | 2 2 0.1s
> LibSSH2\_jll | None 0.0s
> LibUV\_jll | 1 1 0.1s
> LibUnwind\_jll | None 0.0s
> Libdl | 130 1 131 0.8s
> Logging | 40 40 1.3s
> MPFR\_jll | 1 1 0.1s
> Markdown | 257 257 5.1s
> MbedTLS\_jll | 1 1 0.1s
> SparseArrays/sparsematrix\_constructors\_indexing | 1830 1830 4m03.8s
> MozillaCACerts\_jll | 1 1 0.0s
> NetworkOptions | 3518 3518 1.5s
> OpenBLAS\_jll | 1 1 0.0s
> OpenLibm\_jll | 1 1 0.1s
> PCRE2\_jll | 2 2 0.1s
> InteractiveUtils | 301 1 302 23.3s
> Printf | 1017 1017 15.1s
> Mmap | 138 138 27.0s
> Profile | 109 109 30.8s
> REPL | 1545 3 1548 28.7s
> Serialization | 129 1 130 7.6s
> Downloads | 232 4 236 1m41.7s
> Random | 204839 204839 1m00.3s
> SuiteSparse | None 0.1s
> SuiteSparse\_jll | 1 1 0.1s
> SparseArrays/sparsevector | 10365 4 10369 3m55.5s
> SHA | 107 107 58.6s
> TOML | 415 8 423 12.2s
> UUIDs | 1029 1029 0.3s
> FileWatching | 590 590 2m00.8s
> Zlib\_jll | 1 1 0.1s
> dSFMT\_jll | 1 1 0.1s
> libLLVM\_jll | 1 1 0.0s
> libblastrampoline\_jll | 1 1 0.0s
> nghttp2\_jll | 1 1 0.1s
> p7zip\_jll | 1 1 0.0s
> Unicode | 795 795 5.2s
> Tar | 1675 11 1686 31.6s
> Test | 457 18 475 44.8s
> Sockets | 170 1 171 1m25.6s
> Statistics | 810 810 1m11.8s
> precompile | 155 155 36.0s
> SharedArrays | 114 114 25.8s
> threads | 45 3 48 2m40.5s
> Distributed | 15 15 4m02.6s
> stress | None 0.0s
> FAILURE
> 
> The global RNG seed was 0x50899771fb1b987f4e0bc680062ccf9b.
> 
> Error in testset Downloads:
> Test Failed at V:\\julia\\julia-mingw64\\usr\\share\\julia\\stdlib\\v1.9\\Downloads\\test\\runtests.jl:328
> Expression: startswith(err.message, "Could not resolve host")
> Evaluated: startswith("schannel: failed to receive handshake, SSL/TLS connection failed", "Could not resolve host")
> Error in testset Downloads:
> Test Failed at V:\\julia\\julia-mingw64\\usr\\share\\julia\\stdlib\\v1.9\\Downloads\\test\\runtests.jl:329
> Expression: err.response.proto === nothing
> Evaluated: "https" === nothing
> Error in testset Downloads:
> Test Failed at V:\\julia\\julia-mingw64\\usr\\share\\julia\\stdlib\\v1.9\\Downloads\\test\\runtests.jl:334
> Expression: startswith(err.message, "Could not resolve host")
> Evaluated: startswith("schannel: failed to receive handshake, SSL/TLS connection failed", "Could not resolve host")
> Error in testset Downloads:
> Test Failed at V:\\julia\\julia-mingw64\\usr\\share\\julia\\stdlib\\v1.9\\Downloads\\test\\runtests.jl:335
> Expression: err.response.proto === nothing
> Evaluated: "https" === nothing
> ERROR: LoadError: Test run finished with errors
> in expression starting at V:\\julia\\test\\runtests.jl:93
> make\[1\]: \*\*\* \[/v/julia/test/Makefile:25: default\] Error 1
> make\[1\]: Leaving directory '/v/julia/julia-mingw64/test'
> make: \*\*\* \[/v/julia/Makefile:554：test\] Error 2
> make: Leaving directory “/v/julia/julia-mingw64”
> \`\`\`
> \</details\>
> 
> \<details\>
> \<summary\>mingw32 test log\</summary\>
> 
> 
> \### build
> \`\`\`
> Sysimage built. Summary:
> Base ──────── 44.956533 seconds 51.2369%
> Stdlibs ───── 42.784159 seconds 48.7611%
> Total ─────── 87.742447 seconds
> make\[1\]: Leaving directory '/v/julia/julia-mingw32'
> make\[1\]: Entering directory '/v/julia/julia-mingw32'
> JULIA julia-mingw32/usr/lib/julia/sys-o.a
> Generating REPL precompile statements... 40/40
> Executing precompile statements... 2021/2055
> Precompilation complete. Summary:
> Generation ── 440.473837 seconds 63.686%
> Execution ─── 251.159706 seconds 36.314%
> Total ─────── 691.633543 seconds
> Outputting sysimage file...
> Output ────── 156.656760 seconds
> \`\`\`
> 
> \### test
> 
> version
> \`\`\`
> julia\> versioninfo()
> Julia Version 1.9.0-DEV.1040
> Commit c7ff32668c\* (2022-07-28 07:53 UTC)
> Platform Info:
> OS: Windows (i686-w64-mingw32)
> CPU: 6 × Intel(R) Core(TM) i5-9400F CPU @ 2.90GHz
> WORD\_SIZE: 32
> LIBM: libopenlibm
> LLVM: libLLVM-14.0.5 (ORCJIT, skylake)
> Threads: 1 on 6 virtual cores
> \`\`\`
> 
> \- Downloads: Fail x1
> \`\`\`
> Test Summary: | Pass Error Broken Total Time
> Overall | 40435126 1 352668 40787795 70m14.0s
> LinearAlgebra/schur | 496 496 1m05.1s
> LinearAlgebra/eigen | 512 512 1m20.3s
> LinearAlgebra/qr | 4705 4705 3m00.4s
> LinearAlgebra/bunchkaufman | 5688 5688 42.6s
> LinearAlgebra/lapack | 802 802 44.4s
> LinearAlgebra/svd | 566 566 1m17.9s
> LinearAlgebra/special | 2942 2942 4m47.9s
> LinearAlgebra/tridiag | 1541 1541 1m10.3s
> LinearAlgebra/dense | 8475 8475 6m31.8s
> LinearAlgebra/cholesky | 2509 2509 2m17.9s
> LinearAlgebra/matmul | 1486 1486 7m51.5s
> LinearAlgebra/bidiag | 4736 4736 4m17.3s
> LinearAlgebra/lu | 1368 1368 2m13.9s
> LinearAlgebra/generic | 630 630 58.6s
> LinearAlgebra/lq | 2938 2938 57.5s
> LinearAlgebra/uniformscaling | 446 446 1m23.7s
> LinearAlgebra/hessenberg | 631 631 1m28.6s
> LinearAlgebra/adjtrans | 347 347 35.6s
> LinearAlgebra/pinv | 500 500 18.5s
> LinearAlgebra/blas | 1629 1629 1m05.7s
> LinearAlgebra/givens | 1847 1847 16.4s
> LinearAlgebra/ldlt | 8 8 1.1s
> LinearAlgebra/factorization | 80 16 96 4.5s
> ambiguous | 104 2 106 8.9s
> compiler/inference | 1200 2 1202 23.5s
> compiler/effects | 35 35 0.9s
> compiler/validation | 28 28 0.4s
> LinearAlgebra/diagonal | 2877 2877 6m48.1s
> compiler/ssair | 69 69 6.8s
> compiler/irpasses | 139 4 143 5.2s
> compiler/inline | 226 1 227 7.2s
> LinearAlgebra/structuredbroadcast | 670 670 1m13.5s
> compiler/contextual | 12 12 4.7s
> compiler/codegen | 173 173 20.7s
> compiler/AbstractInterpreter | 12 12 8.9s
> compiler/EscapeAnalysis/local | 347 21 368 16.2s
> compiler/EscapeAnalysis/interprocedural | 32 4 36 11.2s
> strings/search | 876 876 9.0s
> strings/basic | 87693 87693 16.0s
> strings/io | 12764 12764 4.6s
> strings/util | 1147 1147 16.1s
> unicode/utf8 | 19 19 0.2s
> strings/types | 2302691 2302691 6.8s
> worlds | 88 88 3.6s
> LinearAlgebra/symmetric | 2847 2847 5m25.0s
> keywordargs | 151 151 3.0s
> atomics | 3448 3448 51.8s
> subtype | 337681 19 337700 15.1s
> char | 1639 1639 4.2s
> triplequote | 29 29 0.6s
> intrinsics | 309 309 5.5s
> core | 8445939 3 8445942 1m56.6s
> LinearAlgebra/triangular | 37908 37908 14m35.1s
> dict | 144426 144426 37.1s
> iobuffer | 209 209 2.4s
> staged | 65 65 10.6s
> hashing | 12519 12519 21.9s
> numbers | 1584721 1 1584722 2m05.7s
> tuple | 666 666 16.7s
> reduce | 8591 8591 46.8s
> offsetarray | 502 3 505 1m07.9s
> subarray | 318323 318323 4m35.8s
> simdloop | 240 240 3.2s
> vecelement | 678 678 7.7s
> rational | 98695 2 98697 39.0s
> reducedim | 1225 6 1231 2m15.0s
> copy | 544 544 4.9s
> arrayops | 2089 6 2095 2m53.7s
> fastmath | 946 946 6.8s
> functional | 98 98 10.5s
> math | 1909879 1909879 44.4s
> operators | 13052 13052 14.0s
> ordering | 37 37 3.7s
> path | 1051 12 1063 1.2s
> ccall | 5390 5390 2m38.3s
> parse | 16098 16098 7.2s
> iterators | 86614 86614 4m45.8s
> gmp | 2444 2444 10.4s
> LinearAlgebra/addmul | 5562 5562 12m05.8s
> spawn | 236 4 240 38.0s
> backtrace | 39 1 40 8.5s
> exceptions | 70 70 8.4s
> abstractarray | 55542 24795 80337 8m22.2s
> file | 767 767 22.0s
> version | 2453 2453 1.4s
> namedtuple | 216 216 6.6s
> mpfr | 1137 1 1138 23.5s
> broadcast | 525 525 1m35.6s
> sorting | 24193 9 24202 3m26.2s
> loading | 154923 154923 5m00.1s
> floatapprox | 49 49 2.3s
> regex | 142 142 3.3s
> reflection | 427 427 10.5s
> complex | 8480 2 8482 12.6s
> sysinfo | 4 4 0.1s
> env | 178 178 0.7s
> float16 | 762093 762093 8.4s
> combinatorics | 172 172 9.0s
> rounding | 150016 150016 7.6s
> mod2pi | 80 80 0.6s
> euler | 12 12 2.2s
> client | 5 5 2.7s
> errorshow | 246 246 19.9s
> read | 3810 3810 3m14.9s
> goto | 19 19 0.1s
> llvmcall | 19 19 1.0s
> show | 128892 8 128900 39.7s
> llvmcall2 | 20 20 0.3s
> some | 72 72 1.6s
> ryu | 31215 31215 1.9s
> stacktraces | 48 48 2.4s
> meta | 69 69 2.6s
> docs | 239 239 7.5s
> binaryplatforms | 341 341 9.0s
> sets | 3643 1 3644 36.9s
> enums | 100 100 5.1s
> ranges | 12110694 327682 12438376 1m15.2s
> intfuncs | 227811 227811 12m05.4s
> interpreter | 3 3 2.5s
> atexit | 40 40 12.7s
> bitset | 195 195 3.8s
> checked | 1239 1239 12.5s
> misc | 1282197 1282197 52.9s
> error | 33 33 4.1s
> boundscheck | None 20.5s
> osutils | 57 57 0.2s
> cartesian | 349 3 352 13.0s
> iostream | 50 50 1.6s
> int | 736188 736188 48.2s
> specificity | 175 175 1.0s
> secretbuffer | 30 30 1.9s
> syntax | 1659 1 1660 16.2s
> channels | 256 256 30.8s
> reinterpretarray | 421 421 22.7s
> corelogging | 235 235 7.7s
> smallarrayshrink | 36 36 0.5s
> opaque\_closure | 66 1 67 1.3s
> filesystem | 6 6 0.6s
> download | None 6.4s
> SparseArrays/ambiguous | 1 1 7.1s
> missing | 574 1 575 30.1s
> asyncmap | 307 307 27.2s
> SparseArrays/sparsematrix\_ops | 415 415 58.5s
> floatfuncs | 232 232 3m41.0s
> SparseArrays/linalg | 1814 1814 1m45.6s
> cmdlineargs | 274 5 279 4m32.3s
> SparseArrays/higherorderfns | 7145 1 7146 3m27.1s
> SparseArrays/linalg\_solvers | 364 364 37.6s
> SparseArrays/issues | 326 326 1m49.2s
> SparseArrays/cholmod | 607 607 44.3s
> SparseArrays/spqr | 91 91 14.5s
> SparseArrays/umfpack | 200 200 1m03.1s
> Dates/accessors | 7723858 7723858 8.4s
> SparseArrays/sparsematrix\_constructors\_indexing | 1830 1830 4m23.5s
> Dates/query | 1004 1004 1.2s
> Dates/adjusters | 3149 3149 6.8s
> Dates/rounding | 315 315 4.4s
> Dates/types | 232 232 2.8s
> LibGit2/libgit2 | 595 595 33.4s
> Dates/periods | 953 953 27.9s
> Dates/conversions | 160 160 1.8s
> Dates/ranges | 350639 350639 29.9s
> Dates/io | 332 332 20.2s
> Base64 | 2031 2031 3.8s
> CRC32c | 664 664 0.7s
> CompilerSupportLibraries\_jll | 4 4 0.0s
> Dates/arithmetic | 385 385 13.0s
> DelimitedFiles | 89 89 9.6s
> Artifacts | 1452 1452 18.5s
> Future | None 0.0s
> GMP\_jll | 1 1 0.0s
> ArgTools | 180 180 46.9s
> LLVMLibUnwind\_jll | None 0.0s
> LazyArtifacts | 4 4 7.6s
> InteractiveUtils | 301 1 302 36.5s
> LibCURL\_jll | 1 1 0.0s
> LibGit2\_jll | 2 2 0.1s
> LibSSH2\_jll | None 0.0s
> LibUV\_jll | 1 1 0.0s
> LibUnwind\_jll | None 0.0s
> Libdl | 119 1 120 1.0s
> LibCURL | 6 6 2.5s
> MPFR\_jll | 1 1 0.1s
> Logging | 40 40 1.5s
> MbedTLS\_jll | 1 1 0.0s
> Markdown | 257 257 8.8s
> MozillaCACerts\_jll | 1 1 0.0s
> NetworkOptions | 3518 3518 1.5s
> OpenBLAS\_jll | 1 1 0.0s
> OpenLibm\_jll | 1 1 0.1s
> Downloads | 1 1 1m01.1s
> PCRE2\_jll | 2 2 0.3s
> Printf | 1017 1017 16.0s
> Mmap | 138 138 26.4s
> SparseArrays/sparsevector | 10365 4 10369 3m50.7s
> REPL | 1545 3 1548 39.9s
> Serialization | 129 1 130 7.4s
> FileWatching | 590 590 2m02.7s
> Random | 204833 204833 1m10.4s
> SuiteSparse | None 0.1s
> SuiteSparse\_jll | 1 1 0.1s
> TOML | 415 8 423 20.5s
> Sockets | 170 1 171 1m28.1s
> Statistics | 810 810 1m28.9s
> UUIDs | 1029 1029 0.6s
> Unicode | 795 795 6.1s
> Zlib\_jll | 1 1 0.1s
> dSFMT\_jll | 1 1 0.0s
> libLLVM\_jll | 1 1 0.0s
> libblastrampoline\_jll | 1 1 0.0s
> nghttp2\_jll | 1 1 0.1s
> p7zip\_jll | 1 1 0.0s
> SHA | 107 107 2m14.2s
> Test | 457 18 475 1m01.6s
> Tar | 1675 11 1686 2m13.4s
> bitarray | 913196 913196 23m17.4s
> Profile | 109 109 34m35.5s
> precompile | 155 155 48.6s
> SharedArrays | 114 114 45.3s
> threads | 45 3 48 5m15.9s
> Distributed | 15 15 6m48.2s
> stress | None 0.0s
> FAILURE
> 
> The global RNG seed was 0x3af2fbe3ce42df5abab7ba751263a17d.
> 
> Error in testset Downloads:
> Error During Test at none:1
> Got exception outside of a @test
> ProcessExitedException(4)
> Stacktrace:
> \[1\] try\_yieldto(undo::typeof(Base.ensure\_rescheduled))
> @ Base .\\task.jl:888
> \[2\] wait()
> @ Base .\\task.jl:952
> \[3\] wait(c::Base.GenericCondition{ReentrantLock})
> @ Base .\\condition.jl:124
> \[4\] take\_buffered(c::Channel{Any})
> @ Base .\\channels.jl:416
> \[5\] take!(c::Channel{Any})
> @ Base .\\channels.jl:410
> \[6\] take!(::Distributed.RemoteValue)
> @ Distributed V:\\julia\\julia-mingw32\\usr\\share\\julia\\stdlib\\v1.9\\Distributed\\src\\remotecall.jl:726
> \[7\] remotecall\_fetch(::Function, ::Distributed.Worker, ::String, ::Vararg{String}; kwargs::Base.Pairs{Symbol, UInt128, Tuple{Symbol}, NamedTuple{(:seed,), Tuple{UInt128}}})
> @ Distributed V:\\julia\\julia-mingw32\\usr\\share\\julia\\stdlib\\v1.9\\Distributed\\src\\remotecall.jl:461
> \[8\] remotecall\_fetch(::Function, ::Int32, ::String, ::Vararg{String}; kwargs::Base.Pairs{Symbol, UInt128, Tuple{Symbol}, NamedTuple{(:seed,), Tuple{UInt128}}})
> @ Distributed V:\\julia\\julia-mingw32\\usr\\share\\julia\\stdlib\\v1.9\\Distributed\\src\\remotecall.jl:492
> \[9\] macro expansion
> @ V:\\julia\\test\\runtests.jl:260 \[inlined\]
> \[10\] (::var"#45#57"{Vector{Task}, var"#print\_testworker\_errored#53"{ReentrantLock, Int32, Int32}, var"#print\_testworker\_stats#51"{ReentrantLock, Int32, Int32, Int32, Int32, Int32, Int32}, Vector{Any}, Dict{String, DateTime}})()
> @ Main .\\task.jl:501
> ERROR: LoadError: Test run finished with errors
> in expression starting at V:\\julia\\test\\runtests.jl:93
> make\[1\]: \*\*\* \[/v/julia/test/Makefile:25: default\] Error 1
> make\[1\]: Leaving directory '/v/julia/julia-mingw32/test'
> make: \*\*\* \[/v/julia/Makefile:554：test\] Error 2
> make: Leaving directory “/v/julia/julia-mingw32”
> \`\`\`
> \</details\>
> 
> \----
> 
> Next step todo:
> \- \[x\] make a Dockerfile

full test log:

> <https://gist.github.com/inkydragon/548d2eb99955c758b6c6b907b03aeaa8>

* * *

> [@Palli](#):
>
> just no longer a tier 2 platform.

So, you mean move Win i686 (32-bit) from “tier 2” to “tire 3”.

Do we want to keep the 32bit CI?

---

<div class="post-metadata">

**Author:** ![blackeneth](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/blackeneth/32/10353_2.png) [@blackeneth](https://discourse.julialang.org/u/blackeneth)\
**Post date:** [October 31, 2022, 5:11am UTC](https://discourse.julialang.org/t/is-anyone-using-32-bit-julia-on-windows/89525/4 "2022-10-31T05:11:32Z")

</div>

I wonder what is the number of Windows 32-bit downloads?

---

<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:** [October 31, 2022, 9:09am UTC](https://discourse.julialang.org/t/is-anyone-using-32-bit-julia-on-windows/89525/5 "2022-10-31T09:09:16Z")

</div>

> [@woclass](#):
>
> So, you mean move Win i686 (32-bit) from “tier 2” to “tire 3”.

To tier 3, or 4 or not offered at all. I don’t really care, whatever makes sense. I don’t even use 64-bit Windows, though I want that kept. 🙂

> [@dlakelan](#):
>
> but just want to point out that a lot of small cheap SBCs such as Raspberry Pi are still using 32 bit so the Linux version makes sense.

Right, why I want it kept. I’ve not used 32-bit, except downloaded by accident (then 32-bit snap Julia, it’s now 64-bit), and also intentionally for some testing. Might apply for some Win32 too, or just downloaded by mistake, so I’m curious about the download numbers too.

---

<div class="post-metadata">

**Author:** ![GunnarFarneback](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/gunnarfarneback/32/1827_2.png) [@GunnarFarneback](https://discourse.julialang.org/u/GunnarFarneback)\
**Post date:** [October 31, 2022, 10:37am UTC](https://discourse.julialang.org/t/is-anyone-using-32-bit-julia-on-windows/89525/6 "2022-10-31T10:37:21Z")

</div>

I get a feeling of deja vu and am certain I’ve written this before.

I have exactly one use case for 32-bit Julia on Windows and that is to `ccall` into a proprietary binary-only 32-bit dll needed to communicate with a piece of expensive hardware. That library will never be updated to something sane although the hardware might break at some point. But I also have no need to update to new Julia versions for this use case.

---

<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:** [October 31, 2022, 11:12am UTC](https://discourse.julialang.org/t/is-anyone-using-32-bit-julia-on-windows/89525/7 "2022-10-31T11:12:09Z")

</div>

So that means you DON’T want Win32 supported forever (just for you)? But possibly needed for others? It would still be supported with Julia 1.6 LTS, at least until it’s no longer LTS… and unsupported Julia versions will keep working…

Since this could be a problem for people (in your situation, and we certainly want Julia to work for “expensive hardware”, I suppose, for science) into the foreseeable future, I was curious if there’s a workaround, but it means having a different 32-bit process (that would then not be Julia, or older Julia LTS, you think could be fast enough; for you?):

> <https://stackoverflow.com/questions/128445/calling-32bit-code-from-64bit-process>

> You’ll need to have the 32-bit dll loaded into a separate 32-bit process, and have your 64 bit process communicate with it via interprocess communication. I don’t think there is any way a 32-bit dll can be loaded into a 64 bit process otherwise.
> 
> There is a pretty good article here:
> 
> [Accessing 32-bit DLLs from 64-bit code](http://blog.mattmags.com/2007/06/30/accessing-32-bit-dlls-from-64-bit-code/)

> <https://stackoverflow.com/questions/359331/access-x86-com-from-x64-net>

> 1. Host the COM component out-of-process using the [COM surrogate](http://msdn.microsoft.com/en-us/library/ms684044(VS.85).aspx) DLLhost.exe. This will make calls to the COM server much, much slower (they will now be interprocess Windows messages instead of native function calls), but is otherwise transparent (you don’t have to do anything special).

---

<div class="post-metadata">

**Author:** ![giordano](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/giordano/32/2166_2.png) [@giordano](https://discourse.julialang.org/u/giordano)\
**Post date:** [October 31, 2022, 11:31am UTC](https://discourse.julialang.org/t/is-anyone-using-32-bit-julia-on-windows/89525/8 "2022-10-31T11:31:14Z")

</div>

You can look at the PkgServer statistics, they’re public: [Announcing: package download stats!](https://discourse.julialang.org/t/announcing-package-download-stats/69073)

---

<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:** [October 31, 2022, 12:57pm UTC](https://discourse.julialang.org/t/is-anyone-using-32-bit-julia-on-windows/89525/9 "2022-10-31T12:57:24Z")

</div>

Thanks, I did take a look at julia\_systems.csv, the Win32 downloads (excluding CI downloads), they are not nothing but on the decline, are there are e.g. 741 users for 1.7.2 (0.94% of Windows users for that Julia version) vs. 78370 for Win64 and 32699 for Apple:

 ![mynd](https://global.discourse-cdn.com/julialang/original/3X/0/d/0debad59fe0594570b7c4d65290d797abf0a2d62.png)

I’m plotting request\_addrs column (is request\_count the right column to plot (seems too high) or successes which is lower?)

Most frequent it (single version, not cumulative):

x86\_64-w64-mingw32-libgfortran5-cxx11-julia\_version+1.7.2 at 78370 (well CI number is highest 572236 for a single Linux version)

or rather unbelievable 10891633 user, non-CI, request\_count for x86\_64-linux-gnu-libgfortran5-cxx11-libstdcxx29-julia\_version+1.7.2 highest

I wasn’t expecting 1.10:  
x86\_64-apple-darwin-libgfortran4-cxx11-julia\_version+1.10.0

Surprisingly I did see a download for RISC-V CPU: riscv64-linux-gnu-libgfortran5-cxx11-libstdcxx30-julia\_version+1.9.0

---

<div class="post-metadata">

**Author:** ![mkitti](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/mkitti/32/12459_2.png) [@mkitti](https://discourse.julialang.org/u/mkitti)\
**Post date:** [July 19, 2023, 4:25am UTC](https://discourse.julialang.org/t/is-anyone-using-32-bit-julia-on-windows/89525/10 "2023-07-19T04:25:55Z")

</div>

I noticed that conda-forge dropped support for 32-bit Windows:

> <https://github.com/conda-forge/staged-recipes/issues/5640>
>
> Dear all,
> 
> The results of our Windows 32 support poll are in.
> 
> We had 91 res…ponses, 5 users are using Win32 and only 1 is using Win32 exclusively.
> 
> We believe that this result supports our decision to stop supporting Windows 32.
> This drop will free half of our CI time on Windows and will ensure that Win64 packages are built and shipped much faster.
> 
> We understand that this decision may hurt some users and we apologize for that,
> but the advantages outweigh the disadvantages.
> 
> Thank you for your understanding.

Anaconda’s miniconda has not been updated for 32-bit Windows since Python 3.9 (no Python 3.10, Python 3.11 releases)  
[https://docs.conda.io/en/latest/miniconda.html](https://docs.conda.io/en/latest/miniconda.html)

SciPy apparent dropped 32-bit Windows support as of version 1.9.2 in October 2022:

> **[Dropping 32-bit packages](https://discuss.python.org/t/dropping-32-bit-packages/5476/10)**
>
> SciPy has dropped support since 1.9.2, released Oct’22. 1.9.1 was the last release to have 32-bit Windows wheels. SciPy received few complaints, nor am I aware of many complaints when Anaconda dropped 32-bit support. So I think it’s safe to say...

> **[Release SciPy 1.9.2 · scipy/scipy](https://github.com/scipy/scipy/releases/tag/v1.9.2)**
>
> SciPy 1.9.2 Release Notes
> SciPy 1.9.2 is a bug-fix release with no new features
> compared to 1.9.1. It also provides wheels for Python 3.11
> on several platforms.
> Authors
> 
> Hood Chatham (1)
> Thomas J. ...

I think we should start considering an end-of-life plan for 32-bit Windows support. The first question might be when support degrades to Tier 2 from Tier 1.

---

<div class="post-metadata">

**Author:** ![woclass](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/woclass/32/212699_2.png) [@woclass](https://discourse.julialang.org/u/woclass)\
**Post date:** [July 19, 2023, 4:57am UTC](https://discourse.julialang.org/t/is-anyone-using-32-bit-julia-on-windows/89525/11 "2023-07-19T04:57:36Z")

</div>

When we migrate to using UCRT, we may only be able to support x86\_64 if we don’t want to add support for libc++.

MSYS2 env set

> **[MSYS2 - Environments](https://www.msys2.org/docs/environments/)**
>
> The differences between the environments is mainly between environment variables, default compilers/linkers, architecture, system libraries used etc.

now

- mingw32: gcc-i686 + msvcrt + libstdc++
- mingw64: gcc-x86\_64 + msvcrt + libstdc++

use new UCRT

- ucrt64: gcc-x86\_64 + ucrt + libstdc++

or UCRT + libc++

- clang64: llvm-x86\_64 + ucrt + libc++
- clang32: llvm-i686 + ucrt + libc++

NOTE: Cygwin doesn’t seem to support UCRT at the moment.

---

<div class="post-metadata">

**Author:** ![sob](https://avatars.discourse-cdn.com/v4/letter/s/65b543/32.png) [@sob](https://discourse.julialang.org/u/sob)\
**Post date:** [July 19, 2023, 5:48am UTC](https://discourse.julialang.org/t/is-anyone-using-32-bit-julia-on-windows/89525/12 "2023-07-19T05:48:23Z")

</div>

> [@dlakelan](#):
>
> I know you are talking about windows specifically but just want to point out that a lot of small cheap SBCs such as Raspberry Pi are still using 32 bit so the Linux version makes sense.

Not a single Raspberri Pi model is x86, they’re all ARM. From the Supported Platforms section of the Downloads page, I see ARMv8 64bits is Tier 2 and ARMv7 32bits is Tier 3, on Linux. So already not Tier 1. They do not enjoy the 32 bits x86 Windows (or Linux) Tier 1 status.

---

<div class="post-metadata">

**Author:** ![mkitti](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/mkitti/32/12459_2.png) [@mkitti](https://discourse.julialang.org/u/mkitti)\
**Post date:** [July 19, 2023, 1:20pm UTC](https://discourse.julialang.org/t/is-anyone-using-32-bit-julia-on-windows/89525/13 "2023-07-19T13:20:10Z")

</div>

One note thst I saw suggested that ARM64 Windows users could use 32-bit Windows binaries via emulation

---

<div class="post-metadata">

**Author:** ![sob](https://avatars.discourse-cdn.com/v4/letter/s/65b543/32.png) [@sob](https://discourse.julialang.org/u/sob)\
**Post date:** [July 19, 2023, 3:40pm UTC](https://discourse.julialang.org/t/is-anyone-using-32-bit-julia-on-windows/89525/14 "2023-07-19T15:40:28Z")

</div>

I was actually thinking just that, and I feel sorry for those who do active development on 32 bits, just because their hardware has to be old enough that compilation times are beyond painful. I have a 3 year old decent mobile amd64 CPU and I feel like upgrading to a recent top of the line CPU just for Julia.

---

<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:** [July 19, 2023, 4:52pm UTC](https://discourse.julialang.org/t/is-anyone-using-32-bit-julia-on-windows/89525/15 "2023-07-19T16:52:02Z")

</div>

Python still supports 32-bit, and while they do (maybe for good reasons, a lot more Python out there, possibly e.g. in 32-bit games), that’s not an argument I’m making that we should to it too, even though we compete with them. I see it’s still tier 1 for them:

> **[PEP 11 – CPython platform support | peps.python.org](https://peps.python.org/pep-0011/)**
>
> Python Enhancement Proposals (PEPs)

> CPython’s Windows support currently follows Microsoft’s lifecycles.

i.e. I believe that means they want to support 32-bit Windows, thus 32-bit CPUs, as long as Microsoft does. I’m sure they want to drop it soon enough. It makes no economic sense for us (or them) to support 32-bit Windows, by now only Windows 10.

Windows 11, and Server, only support 64-bit. 8.1 is now out of support.

Supporting 32-bit x86 (IA-32) is about supporting older than 10-year-old computers (in case of Atom, some were only 32-bit, i.e. Bonnell from 2008, discontinued in 2013), or 18-year-old CPUs (non-Atom). Intel supported 64-bit x86-64 in “May 25, 2005; 18 years ago” with Pentium D/Netburst, “Discontinued July 13, 2010; 12 years ago.” AMD introduced x86-64 earlier in 2003.

I believe you can no longer buy new (or used?) 32-bit Windows computer, i.e. with a 32-bit CPU, or 64-bit CPU (but 32-bit Windows installed, why would you?).

> All non-LTSC versions:  
> Supported until October 14, 2025, with the latest feature updates.

Though Windows “IoT: Mainstream support until January 12, 2027 and extended support until January 13, 2032”. We don’t really need to support Windows IoT.

[https://www.microsoft.com/en-gb/software-download/windows10ISO](https://www.microsoft.com/en-gb/software-download/windows10ISO)

> **64-bit or 32-bit processor (CPU).** You’ll create either the 64-bit or 32-bit version of Windows 10 that’s appropriate for your CPU.

The requirements:

> **RAM:** 1 gigabyte (GB) for 32-bit or 2 GB for 64-bit

The cheapest computer at $87 and $176.69 Amazon came op with for 32-bit search were actually 64-bit:

> Fanless Mini PC Win10,Intel X5Atom Z-8350-Dual Band WiFi AC-64-bit Win10/UBuntu 16.4-HD Graphics 2GB+32GB Mini Desktop Computer-HDMI/VGA 1000Mbps LAN Support Dual Screen (Without OEM Key)

> HP EliteDesk 800 G1 Desktop, Intel Core i7 4770 3.4Ghz, 32GB DDR3 RAM

Cheapest on Ebay at $38.71, I think but actually not sure, it’s 64-bit:

> Acer Aspire SW5-012 - Windows 8.1 32 bit, 64 based processorRam 2gbOpens in a new window or tab  
> Pre-Owned

---

<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:** [July 19, 2023, 5:04pm UTC](https://discourse.julialang.org/t/is-anyone-using-32-bit-julia-on-windows/89525/16 "2023-07-19T17:04:58Z")

</div>

Hmm,

Yes, ARM64 can emulate 32-bit Windows binaries (a good thing), but I think your point is they don’t support emulation of 64-bit x86-64. That may be true, and while they could in theory, in either case you cant to recompile. ARM64 is tier 1 for macOS, not yet for Julia ARM64 on Windows (it’s tier 2, already mostly working?). It seems we can and should soon enough. We at least would want to do that, as opposed to

Are Amm-based Windows computers common enough for us to worry about yet? And it’s not that 32-bit Windows Julias will just stop working. Older, including Julia 1.6 LTS will.

If Julia 1.10 (or 1.9) will be LTS, which seems likely, I would rather NOT have it support 32-bit Windows, i.e. not to commit to that for, e.g. 3 years. If we have not lowered from tier 1 by then, we at least could condition the LTS to exclude it.

---

<div class="post-metadata">

**Author:** ![sob](https://avatars.discourse-cdn.com/v4/letter/s/65b543/32.png) [@sob](https://discourse.julialang.org/u/sob)\
**Post date:** [July 19, 2023, 5:11pm UTC](https://discourse.julialang.org/t/is-anyone-using-32-bit-julia-on-windows/89525/17 "2023-07-19T17:11:55Z")

</div>

Is it purely to keep on supporting very old code though? Meaning it’s an issue Python has (don’t want to break or stop supporting some 2010 code), but Julia doesn’t really have?

---

<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:** [July 19, 2023, 6:50pm UTC](https://discourse.julialang.org/t/is-anyone-using-32-bit-julia-on-windows/89525/18 "2023-07-19T18:50:12Z")

</div>

That’s my guess, yes. Python was at some point 32-bit only, but Julia was 64-bit from the start (and 32-bit also available). I don’t know of a single Julia package that is 32-bit only, more likely some are 64-bit only, because of a bug not making then work in 32-bit too.

In some very exceptional case you may want to call some non-Julia 32-bit code, and that will still be possible if that code runs in a separate process. On Linux, in-process, all the code needs to be either 64-bit or all 32-bit, so if you have e.g. a 32-bit only C library, then you would want 32-bit Julia, and I support keeping 32-bit Julia for Linux around (we have an actual 32-bit Windows libc problem that doesn’t apply to Linux). This might not be a strict restriction in Windows, I’m not sure.

---

<div class="post-metadata">

**Author:** ![mkitti](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/mkitti/32/12459_2.png) [@mkitti](https://discourse.julialang.org/u/mkitti)\
**Post date:** [July 19, 2023, 8:43pm UTC](https://discourse.julialang.org/t/is-anyone-using-32-bit-julia-on-windows/89525/19 "2023-07-19T20:43:46Z")

</div>

The problem I am seeing is that our scientific and numeric computing couterparts on the Python side are dropping support for important packages. This means that eventually our Julia frontends for those underlying libraries will begin to degrade on that platform.

---

<div class="post-metadata">

**Author:** ![Benny](https://avatars.discourse-cdn.com/v4/letter/b/49beb7/32.png) [@Benny](https://discourse.julialang.org/u/Benny)\
**Post date:** [July 19, 2023, 8:50pm UTC](https://discourse.julialang.org/t/is-anyone-using-32-bit-julia-on-windows/89525/20 "2023-07-19T20:50:08Z")

</div>

> [@Palli](#):
>
> I believe you can no longer buy new (or used?) 32-bit Windows computer

As I understand it, new Windows versions are all 64-bit after 2020, so there are no new 32-bit versions being given to computer manufacturers, who are independently phasing out their 32-bit processors.

> [@mkitti](#):
>
> One note thst I saw suggested that ARM64 Windows users could use 32-bit Windows binaries via emulation

Windows 11 on ARM recently introduced 64-bit Windows support, I think Windows 10 on ARM is still only 32-bit emulation, a little inconvenient with the phasing out process now but apparently it’s what was in demand.

This is in the context of personal computers, though, embedded systems and microcontrollers seems like its own can of worms when Julia gets to the point it can fit on them on a regular basis.

[Next page](https://discourse.julialang.org/t/is-anyone-using-32-bit-julia-on-windows/89525.md?page=2)