Julia Julia

Open-source Julia projects categorized as Julia

Top 23 Julia Julium Projects

  • julia

    The Julia Programming Language

    Project mention: Dart 3.3 | news.ycombinator.com | 2024-02-15

    3. dispatch on all the arguments

    the first solution is clean, but people really like dispatch.

    the second makes calling functions in the function call syntax weird, because the first argument is privileged semantically but not syntactically.

    the third makes calling functions in the method call syntax weird because the first argument is privileged syntactically but not semantically.

    the closest things to this i can think of off the top of my head in remotely popular programming languages are: nim, lisp dialects, and julia.

    nim navigates the dispatch conundrum by providing different ways to define free functions for different dispatch-ness. the tutorial gives a good overview: https://nim-lang.org/docs/tut2.html

    lisps of course lack UFCS.

    see here for a discussion on the lack of UFCS in julia: https://github.com/JuliaLang/julia/issues/31779

    so to sum up the answer to the original question: because it's only obvious how to make it nice and tidy like you're wanting if you sacrifice function dispatch, which is ubiquitous for good reason!

  • DifferentialEquations.jl

    Multi-language suite for high-performance solvers of differential equations and scientific machine learning (SciML) components. Ordinary differential equations (ODEs), stochastic differential equations (SDEs), delay differential equations (DDEs), differential-algebraic equations (DAEs), and more in Julia.

  • LearnThisRepo.com

    Learn 300+ open source libraries for free using AI. LearnThisRepo lets you learn 300+ open source repos including Postgres, Langchain, VS Code, and more by chatting with them using AI!

  • Makie.jl

    Interactive data visualizations and plotting in Julia

    Project mention: Julia and Mojo (Modular) Mandelbrot Benchmark | news.ycombinator.com | 2023-09-08
  • Genie.jl

    🧞The highly productive Julia web framework

    Project mention: Tidyverse 2.0.0 | news.ycombinator.com | 2023-04-09

    Julia seems to be doing a better job catching up to R in this space than Python. I haven't used it personally, but the demos of Genie Framework are impressive: https://github.com/GenieFramework/Genie.jl / https://genieframework.com/

  • JuMP.jl

    Modeling language for Mathematical Optimization (linear, mixed-integer, conic, semidefinite, nonlinear)

  • Gadfly.jl

    Crafty statistical graphics for Julia.

  • Plots.jl

    Powerful convenience for Julia visualizations and data analysis

  • WorkOS

    The modern API for authentication & user identity. The APIs are flexible and easy-to-use, supporting authentication, user identity, and complex enterprise features like SSO and SCIM provisioning.

  • MLJ.jl

    A Julia machine learning framework

  • DataFrames.jl

    In-memory tabular data in Julia

    Project mention: Julia's latency: Past, present and future | news.ycombinator.com | 2023-04-01

    I don't think we've seen the final state of it though. v1.9 really gives people the proper tools for solving latency problems. Before, invalidations hurt a little, but it was also kind of a wash because LLVM code didn't precompile, so you could spend time setting up a Snoopprecompile and fix some invalidations and end up LLVM bound saving 1 second out of 20. But with package images it's almost always better to fix precompilation. The only thing hampering time much now is the `using` time went up, but as mentioned in the Reddit post there's a lot of ideas for what to do there. The other thing is package extensions, which cut down the amount of code to load. There's tons of PRs floating around the ecosystem turning things into extensions, and thus cutting down the overall code that is actually ran and loaded.

    This means that in a few months, people will start to see some major tangible benefits from following the compilation improvement practices laid out here and https://sciml.ai/news/2022/09/21/compile_time/. I think then you'll have a lot more people start to take all of these new tools seriously and it will be standard to incorporate them into packages. Right now they are still kind of niche things for packages with known TTFX problems, but I think come v1.9 you'll see every major package use all of these methods.

    > Different packages are affected differently

    I think this is one of the pieces that's effected by this. I don't think "Julia has become optimised for running Plots.jl" is quite correct. Julia's compilation and runtime is much more optimized for well-inferred code, which Plots.jl is not. However, the compiler developers have been using Plots.jl as a test case for all of these new tools, and therefore its SnoopPrecompile and invalidations have gotten some dramatic improvements because those required ecosystem changes I mentioned are being done by the compiler team for this specific package. Plots.jl had things like precompilation snooping way back before there was even a package for it, the earliest I know of was around v1.0. Meanwhile, DataFrames.jl only setup its precompilation snooping 7 months ago (https://github.com/JuliaData/DataFrames.jl/pull/3182), which I would presume was just in time for the v1.8 mark on your plot and is one of the big reasons for having a sudden drop (which continues into v1.9 because of package images).

    What I mean to say then is that, I think all packages will get the improvements we've seen from Plots.jl, but package authors will need to update their packages in order for that to happen. Some packages have already done this, many have not.

  • Zygote.jl

    21st century AD

    Project mention: Yann Lecun: ML would have advanced if other lang had been adopted versus Python | news.ycombinator.com | 2023-02-22

    If you look at Julia open source projects you'll see that the projects tend to have a lot more contributors than the Python counterparts, even over smaller time periods. A package for defining statistical distributions has had 202 contributors (https://github.com/JuliaStats/Distributions.jl), etc. Julia Base even has had over 1,300 contributors (https://github.com/JuliaLang/julia) which is quite a lot for a core language, and that's mostly because the majority of the core is in Julia itself.

    This is one of the things that was noted quite a bit at this SIAM CSE conference, that Julia development tends to have a lot more code reuse than other ecosystems like Python. For example, the various machine learning libraries like Flux.jl and Lux.jl share a lot of layer intrinsics in NNlib.jl (https://github.com/FluxML/NNlib.jl), the same GPU libraries (https://github.com/JuliaGPU/CUDA.jl), the same automatic differentiation library (https://github.com/FluxML/Zygote.jl), and of course the same JIT compiler (Julia itself). These two libraries are far enough apart that people say "Flux is to PyTorch as Lux is to JAX/flax", but while in the Python world those share almost 0 code or implementation, in the Julia world they share >90% of the core internals but have different higher levels APIs.

    If one hasn't participated in this space it's a bit hard to fathom how much code reuse goes on and how that is influenced by the design of multiple dispatch. This is one of the reasons there is so much cohesion in the community since it doesn't matter if one person is an ecologist and the other is a financial engineer, you may both be contributing to the same library like Distances.jl just adding a distance function which is then used in thousands of places. With the Python ecosystem you tend to have a lot more "megapackages", PyTorch, SciPy, etc. where the barrier to entry is generally a lot higher (and sometimes requires handling the build systems, fun times). But in the Julia ecosystem you have a lot of core development happening in "small" but central libraries, like Distances.jl or Distributions.jl, which are simple enough for an undergrad to get productive in a week but is then used everywhere (Distributions.jl for example is used in every statistics package, and definitions of prior distributions for Turing.jl's probabilistic programming language, etc.).

  • PyCall.jl

    Package to call Python functions from the Julia language

    Project mention: I just started into Julia for ML | /r/Julia | 2023-06-06

    For point 3 you can use https://github.com/cjdoris/PythonCall.jl or https://github.com/JuliaPy/PyCall.jl (and their respective Python sister packages).

  • UnicodePlots.jl

    Unicode-based scientific plotting for working in the terminal

    Project mention: UnicodePlots | /r/patient_hackernews | 2023-04-09
  • PackageCompiler.jl

    Compile your Julia Package

    Project mention: Potential of the Julia programming language for high energy physics computing | news.ycombinator.com | 2023-12-04

    Yes, julia can be called from other languages rather easily, Julia functions can be exposed and called with a C-like ABI [1], and then there's also various packages for languages like Python [2] or R [3] to call Julia code.

    With PackageCompiler.jl [4] you can even make AOT compiled standalone binaries, though these are rather large. They've shrunk a fair amount in recent releases, but they're still a lot of low hanging fruit to make the compiled binaries smaller, and some manual work you can do like removing LLVM and filtering stdlibs when they're not needed.

    Work is also happening on a more stable / mature system that acts like StaticCompiler.jl [5] except provided by the base language and people who are more experienced in the compiler (i.e. not a janky prototype)

    [1] https://docs.julialang.org/en/v1/manual/embedding/

    [2] https://pypi.org/project/juliacall/

    [3] https://www.rdocumentation.org/packages/JuliaCall/

    [4] https://github.com/JuliaLang/PackageCompiler.jl

    [5] https://github.com/tshort/StaticCompiler.jl

  • ModelingToolkit.jl

    An acausal modeling framework for automatically parallelized scientific machine learning (SciML) in Julia. A computer algebra system for integrated symbolics for physics-informed machine learning and automated transformations of differential equations

  • BeautifulAlgorithms.jl

    Concise and beautiful algorithms written in Julia

  • AlphaZero.jl

    A generic, simple and fast implementation of Deepmind's AlphaZero algorithm.

  • CUDA.jl

    CUDA programming in Julia.

    Project mention: Ask HN: Best way to learn GPU programming? | news.ycombinator.com | 2024-01-01

    It would also mean learning Julia, but you can write GPU kernels in Julia and then compile for NVidia CUDA, AMD ROCm or IBM oneAPI.

    https://juliagpu.org/

    I've written CUDA kernels and I knew nothing about it going in.

  • Distributions.jl

    A Julia package for probability distributions and associated functions.

    Project mention: Yann Lecun: ML would have advanced if other lang had been adopted versus Python | news.ycombinator.com | 2023-02-22

    If you look at Julia open source projects you'll see that the projects tend to have a lot more contributors than the Python counterparts, even over smaller time periods. A package for defining statistical distributions has had 202 contributors (https://github.com/JuliaStats/Distributions.jl), etc. Julia Base even has had over 1,300 contributors (https://github.com/JuliaLang/julia) which is quite a lot for a core language, and that's mostly because the majority of the core is in Julia itself.

    This is one of the things that was noted quite a bit at this SIAM CSE conference, that Julia development tends to have a lot more code reuse than other ecosystems like Python. For example, the various machine learning libraries like Flux.jl and Lux.jl share a lot of layer intrinsics in NNlib.jl (https://github.com/FluxML/NNlib.jl), the same GPU libraries (https://github.com/JuliaGPU/CUDA.jl), the same automatic differentiation library (https://github.com/FluxML/Zygote.jl), and of course the same JIT compiler (Julia itself). These two libraries are far enough apart that people say "Flux is to PyTorch as Lux is to JAX/flax", but while in the Python world those share almost 0 code or implementation, in the Julia world they share >90% of the core internals but have different higher levels APIs.

    If one hasn't participated in this space it's a bit hard to fathom how much code reuse goes on and how that is influenced by the design of multiple dispatch. This is one of the reasons there is so much cohesion in the community since it doesn't matter if one person is an ecologist and the other is a financial engineer, you may both be contributing to the same library like Distances.jl just adding a distance function which is then used in thousands of places. With the Python ecosystem you tend to have a lot more "megapackages", PyTorch, SciPy, etc. where the barrier to entry is generally a lot higher (and sometimes requires handling the build systems, fun times). But in the Julia ecosystem you have a lot of core development happening in "small" but central libraries, like Distances.jl or Distributions.jl, which are simple enough for an undergrad to get productive in a week but is then used everywhere (Distributions.jl for example is used in every statistics package, and definitions of prior distributions for Turing.jl's probabilistic programming language, etc.).

  • StatsWithJuliaBook

    Project mention: An Introduction to Statistical Learning with Applications in Python | news.ycombinator.com | 2023-07-09

    I actually like this book by Yoni Nazarathy

    https://statisticswithjulia.org/

    They have a book on Mathematics of DL too which is a natural progression from the concepts covered here.

    (I am slightly biased towards this since I've known the author by online interactions)

  • TensorFlow.jl

    A Julia wrapper for TensorFlow

  • model-zoo

    Please do not feed the models

  • Oceananigans.jl

    🌊 Julia software for fast, friendly, flexible, ocean-flavored fluid dynamics on CPUs and GPUs

    Project mention: Julia 1.10 Released | news.ycombinator.com | 2023-12-27

    I think it’s also the design philosophy. JuMP and ForwardDiff are great success stories and are packages very light on dependencies. I like those.

    The DiffEq library seems to pull you towards the SciML ecosystem and that might not be agreeable to everyone.

    For instance a known Julia project that simulates diff equations seems to have implemented their own solver

    https://github.com/CliMA/Oceananigans.jl

  • ForwardDiff.jl

    Forward Mode Automatic Differentiation for Julia

    Project mention: Excited for Julia v1.9 | /r/Julia | 2023-02-23

    Just so you know, v1.9 doesn't solve the load problems. What it does it gives package authors the tools to solve the problems, specifically precompilation as binaries and package extensions. It won't actually solve the load problems until the packages are updated to effectively make use of these features. This is already underway, https://sciml.ai/news/2022/09/21/compile_time/ with things like and https://github.com/JuliaDiff/ForwardDiff.jl/pull/625, but it is a fairly heavy lift to ensure things aren't invalidating and that everything that's necessary is precompiling.

  • InfluxDB

    Power Real-Time Data Analytics at Scale. Get real-time insights from all types of time series data with InfluxDB. Ingest, query, and analyze billions of data points in real-time with unbounded cardinality.

NOTE: The open source projects on this list are ordered by number of github stars. The number of mentions indicates repo mentiontions in the last 12 Months or since we started tracking (Dec 2020). The latest post mention was on 2024-02-15.

Julia Julia related posts

Index

What are some of the best open-source Julium projects in Julia? This list will help you:

Project Stars
1 julia 44,062
2 DifferentialEquations.jl 2,701
3 Makie.jl 2,225
4 Genie.jl 2,151
5 JuMP.jl 2,102
6 Gadfly.jl 1,889
7 Plots.jl 1,782
8 MLJ.jl 1,703
9 DataFrames.jl 1,671
10 Zygote.jl 1,426
11 PyCall.jl 1,421
12 UnicodePlots.jl 1,369
13 PackageCompiler.jl 1,355
14 ModelingToolkit.jl 1,302
15 BeautifulAlgorithms.jl 1,292
16 AlphaZero.jl 1,200
17 CUDA.jl 1,099
18 Distributions.jl 1,057
19 StatsWithJuliaBook 1,056
20 TensorFlow.jl 880
21 model-zoo 870
22 Oceananigans.jl 861
23 ForwardDiff.jl 842
Power Real-Time Data Analytics at Scale
Get real-time insights from all types of time series data with InfluxDB. Ingest, query, and analyze billions of data points in real-time with unbounded cardinality.
www.influxdata.com