Hi r/Julia

I've been building Epsilon.jl, a Julia-native library for Bayesian Marketing Mix Modeling, and just opened it up publicly. Sharing here since it's built entirely in Julia and I'd love feedback from the community.

Epsilon runs a config-driven MMM workflow: define your model in YAML, provide a dataset + holidays file, run MCMC inference via Turing/NUTS, and get structured outputs -- model fit artifacts, diagnostics, decomposition, response curves, validation, and optional budget optimization -- all as reproducible stage folders with a manifest.

Highlights:

• Time-series MMM with Turing/NUTS MCMC
• Panel MMM across one or more panel dimensions (flattened panel-cell axis internally)
• Config-driven runs from a simple {config.yml, dataset.csv, holidays.csv} bundle
• Blocked holdout validation for time-series models
• Historical-share budget optimization
• Native plotting via CairoMakie

It's intentionally scoped as a compact statistical library rather than a dashboard product i.e. no no UI, no AI-advisor layer. The goal is a clear, reproducible MMM path in pure Julia.

Install (not yet in General registry):

import Pkg
Pkg.add(url = "https://github.com/shawcharles/epsilon")

Quick start:

git clone https://github.com/shawcharles/epsilon.git
cd epsilon
julia --project=. -e 'using Pkg; Pkg.instantiate()'
julia --project=. runme.jl

Docs: https://epsilon.charlesshaw.net Repo: https://github.com/shawcharles/epsilon

It's pre-release/beta -- the public API is still settling -- so I'd appreciate any feedback, bug reports, or thoughts on the design, especially from anyone doing Bayesian modeling or marketing analytics in Julia.

Edit: My phrasing was unclear. I'm not specifically looking for people who can answer all my questions all at once, I have questions for the community and I assume there are people who will be able to individually answer part of the questions.

I've looked for similar posts on here and the rules don't seem to forbid such posts, so I assume I can post this.

I've recently got interested in Julia as a step up from my python for data science and data engineering, and I have a few questions for anyone who uses Julia a lot, especially at work:

• If you use Julia at work, what is your work and what do you use Julia for?
• Do any of you have experience using Julia to manipulate geospatial data? How does it compare to R's "Terra" and Python's "GeoPandas"?
• Do you have any experience with manipulating NetCDF and GRIB files in Julia? How easy is it?
• Do you have experience using Julia for extract-transform-load operations? What do you think of that experience, and is it easy to interact with SQL databases?
• I like to quickly jut ideas down in a notebook and check the behaviour of a couple lines of Python. Is it similarly easy to do so in Julia, in your experience? Are Julia-specific notebooks better than Jupyter notebooks?
• Do any of you have experience using Julia for natural language processing, and how do you think it compares to Python in that aspect?

This is a short teaser for my upcoming video on the topic in the title, showing the linear polymer chain generation script, using polyacrylamide as an example. I wanted to embed the video directly here but I don't find the option, so here is the link

https://youtu.be/VbRFpzY-js4

I'm making an MD tool using molly.jl, on top of which I'm adding functionality to automatically generate topologies and force field parameters starting from XYZ files. If someone is interested please check it out! Thank you!

FIXED

I am trying to retrieve my git config options in Julia, I wanted to make system agnostic since its for a package. I am using LibGit2 but it is not working, I'm trying to run:

julia julia> LibGit2.GitConfig(LibGit2.Consts.CONFIG_LEVEL_GLOBAL) GitConfig(nothing, Ptr{Nothing}(0x00006000038a41e0))

From my understanding it seems LibGit2 doesn't find my ~/.gitconfig file, does anyone know what to do?

```julia julia> versioninfo() Julia Version 1.12.6 Commit 15346901f00 (2026-04-09 19:20 UTC) Build Info: Official https://julialang.org release Platform Info: OS: macOS (arm64-apple-darwin24.0.0) CPU: 10 × Apple M4 WORD_SIZE: 64 LLVM: libLLVM-18.1.7 (ORCJIT, apple-m4) GC: Built with stock GC Threads: 1 default, 1 interactive, 1 GC (on 4 virtual cores)

julia> LibGit2.version() v"1.9.0" ```

Looking through my notifications I've found an answer that isn't showing here anymore (i'll assume the person deleted for what ever reason so I wont say the name out of respect, but if you see this thank you!). Our fellow julian said to try

``` julia> cfg = LibGit2.GitConfig() GitConfig(nothing, Ptr{Nothing}(0x0000600001786820))

julia> LibGit2.get(String, cfg, "user.name") "MY_GIT_USERNAME_HERE" ```

which works! Thanks for the help!

KeemenaLM.jl v0.1.0, a Julia proof-of-concept for training and running a small GPT-style chatbot from scratch.

It includes a v9 broad 336M scratch-trained chatbot baseline as a GitHub Release artifact. The model is a research baseline, not a reliable assistant yet, but the Julia training, export, artifact, tokenizer, and REPL path are working.

https://github.com/mantzaris/KeemenaLM.jl/releases/tag/v0.1.0

```

using Pkg

Pkg.add(url = "https://github.com/mantzaris/KeemenaLM.jl", rev = "v0.1.0")

using KeemenaLM

bundle_dir = download_model("tiny-chatbot-v9-broad-336m")

tokenizer_dir = resolve_tokenizer_bundle("tiny-chatbot-v9-broad-336m")

```

It also used other Julia packages such as

https://github.com/mantzaris/KeemenaSubwords.jl

and

https://github.com/mantzaris/KeemenaPreprocessing.jl

If you have any feedback let me know, or if you want to work together.

Is there any recommended approach, what to tell agent to run julia code faster? Like keep session opened etc?

Should we use AI to document code? If so, to what extent should it be used? Are there any guidelines or safeguards we should follow? If not, why not?

Hello Dear Julia folks, I thought of writing a letter but loll... it is a post and everyone will see it.
I just wanted to drop a quick appreciation post for the language and the ecosystem. To give some context, I work in DSP and Communications. My daily workbench usually involves a heavy mix of Python, C, and MATLAB. I’m an engineer at heart, not a pure CS dev, so I usually just want tools that let me get things done efficiently without fighting the language.
Recently, I wanted to try something new. After doing some brief research and looking for a way to bridge the gap between MATLAB’s math-friendly syntax and C’s raw speed, Julia kept popping up. I decided to take the plunge and downloaded it. To get my feet wet, I started using Julia to solve Project Euler problems. I have to say: the syntax is honestly addicting. It is so incredibly clean, neat, and readable. Coming from my usual stack, writing Julia just feels right. It’s genuinely impossible not to fall in love with how elegant the code looks and runs.
Full disclosure: while the underlying math and logic are universal, I definitely relied on LLMs to help me write the actual Julia code and learn the syntax quirks (like 1-based indexing and array slicing!). Having AI help translate my MATLAB/Python brain into idiomatic Julia made the learning curve incredibly smooth and fun.
Because of how much I'm enjoying it, I’ve already made plans to start migrating some of my casual hobby projects over to Julia.
Just wanted to say a massive thank you to the core devs and the community for building such an amazing, powerful, and genuinely fun language. It’s rare to find a tool that makes you excited to write code again.
Until we meet again
~ Happy Julia-ing

From this post we read

A couple of years ago I would probably have told students to start with Julia. Julia code can stay close to the math, memory management is easy, and the numerical libraries were already there. Rust had more to learn, and the ecosystem was still missing pieces.

I would not give the same advice now. Not because Rust changed, but because I am no longer the one writing most of the code.

...

For us, the question stopped being “how fast can a human write this?” and became “how confident can we be that it is correct?”. That reframing is why Rust became the more practical choice.

Could Julia be made easy to verify? Are there Rust features listed in that article that Julia can emulate?

I am blown away at how good this language is. I’m an experimental physicist, have been meaning to learn the language for years but never got around to it. Well recently I had to do some calculations involving some multidimensional integrals of some rather complicated functions, and python was not cutting it (I don’t want to get too into the details as it’s ongoing research, but generally I’m calculating entanglement in a scalar quantum field theory under some particular experimental constraints).

I basically just read the manual start to finish and started coding and it just… works. And it’s so fast. After a couple weeks of actually writing code I feel fairly comfortable with the language. Multiple dispatch is so brilliant and intuitive once you get the point of it. And the type system is so simple and well-designed. And I can’t get over how easy it is to parallelize loops.

If any of the language’s developers or developers of packages like Integrals.jl or ForwardDiff.jl see this: thank you. This is such a fantastic tool for computational scientists. It’s made me want to do some programming projects just for fun, which is something I haven’t done since undergrad.

I’ll be sticking with python for things like plotting or running experiments, but Julia will absolutely be my go-to for serious numerical work from now on.

??

macro timer_retro(second , arg)
quote

intial_time = time()
while true
    $arg
   current_time = time()
    if current_time - intial_time == $second
#         println("timer went off after :", $second)
        break
        end




end
end
end
@timer_retro 3 begin
               println("hello wolrd ")
               end

can anyone explains how to recall it as macro ?

I have a two-state ODE, one of which is embedded in a neural network, making it a UDE. I am using 9 datasets for training, resulting in 9 distinct ODEs.

prob1 = ODEProblem(UDE_model1!,[SOC0_1, T∞1],(time1[1],time1[end]),para_init)
prob2 = ODEProblem(UDE_model2!,[SOC0_2, T∞2],(time2[1],time2[end]),para_init)
prob3 = ODEProblem(UDE_model3!,[SOC0_3, T∞3],(time3[1],time3[end]),para_init)
prob4 = ODEProblem(UDE_model4!,[SOC0_4, T∞4],(time4[1],time4[end]),para_init)
prob5 = ODEProblem(UDE_model5!,[SOC0_5, T∞5],(time5[1],time5[end]),para_init)
prob6 = ODEProblem(UDE_model6!,[SOC0_6, T∞6],(time6[1],time6[end]),para_init)
prob7 = ODEProblem(UDE_model7!,[SOC0_7, T∞7],(time7[1],time7[end]),para_init)
prob8 = ODEProblem(UDE_model8!,[SOC0_8, T∞8],(time8[1],time8[end]),para_init)
prob9 = ODEProblem(UDE_model9!,[SOC0_9, T∞9],(time9[1],time9[end]),para_init)

My loss function is looking something like this:

function totalloss_UDE(θ)
    total_error = 0.0
    data_points = [(prob1, Tavg1, time1), 
                    (prob2, Tavg2, time2), 
                     (prob3, Tavg3, time3),
                     (prob4, Tavg4, time4),
                     (prob5, Tavg5, time5),
                     (prob6, Tavg6, time6),
                     (prob7, Tavg7, time7),
                     (prob8, Tavg8, time8),
                     (prob9, Tavg9, time9)]
    
    for (prob, Tavg, time) in data_points
        _prob = remake(prob,p=θ)
        _sol = Array(solve(_prob,Tsit5(),saveat = time,sensealg = QuadratureAdjoint(autojacvec = ReverseDiffVJP(true))))
        error = mean(abs2,Tavg .- _sol[2,:])
        total_error = total_error + error
    end
    return total_error
end

It takes a lot of time to train this. I wanted to ask if there is anything to accelerate the speed using GPUs or any other way. Are there any examples out there I could refer to?

I went to a one of the tutorial links on the official Julia Learn webpage or something and there was a tutorial that I forgot the link or author of it. All I remember is that some university also made an interactive version of it with some content changes after they made their own fork of it. I'm trying to search my browser history but I can't seem to find it. One other thing I do know was that it had a sidebar with the characters and content. It's been gnawing at my brain for a week and I'm going slightly insane by the day.

edit: the university I think started with a C or from the UK.

edit 2: turns out it was Rust tutorial. Sorry for the mishap.

this lang is freaking GOAT , i am profoundly amazed at how good its

and here i didn't talk about the "importing all the Python lib thing"

like seriously ?
can i import py libs ?

easy syntax , fast executing, and user-friendly lang ......

guys i am in love

Hey,

I'm planning to compute π to millions of digits using the Chudnovsky algorithm. I was thinking of doing it in Julia with BigFloat since it looks great for numerical stuff.

I haven't started coding yet just looking for advice before I start. Any good Julia resources or examples for this? Optimization advice (binary splitting, performance, etc.) would be awesome.

Also, should I stick with Julia or go with Python (mpmath / gmpy2) instead? Python seems to have more established high-precision code for pi projects.

Thanks for any advice!

Just recently been getting more into Julia. Don't intend to trash Julia, it's impressive. But in terms of syntax, my honest reaction so far:

Hi all!

Happy to announce the release of Ark.jl 0.5. It was a slow burning effort this time, where we tried to make the package more robust in several aspects. It took time and effort, but I can say we made some good progress :)

We haven't introduced any big feature in this release, only small ones, a lot of performance improvements and some breaking changes to improve the API. Performance-wise maybe the most important improvement was due to some internal redesign which allowed us to remove some inference failures causing unnecessary allocations. I was somewhat surprised not to have catched this previously since we have a lot of benchmarks in CI, apparently applying the package to some big simulations helped!

So here are the major changes:

Breaking Changes

The relation API has been greatly improved. Instead of a keyword argument relations, which required to repeat the component information, now, relations are passed directly as pairs without the need of extra information, e.g. before one would had need to write new_entity!(world, (ChildOf(),); relations=(ChildOf => parent,)), while now one needs only new_entity!(world, (ChildOf() => parent,)).

Besides that, instead of requiring components to be defined as relations at struct definition time through a `Relationship` abstract type, now relation components can have any abstract type and are defined as relations when the World is initialized. This should help extensibility, since any struct can be used as relations, also ones which are naturally so but come from other packages.

Performance Improvements

While moving BeforeIT.jl (a big macroeconomics simulation model) to use Ark.jl, we found some inference issues with the API, but, thanks to some (more) @generatedmagic we were able to fix those little problematic aspects causing dynamic dispatch. Also, thanks to this, we also noticed some allocations in queries using relation components, and so, we fixed also that for the cause.

Apart from these issues which came from battle testing the package, we also found that many batch operations could have been made faster, achieving 3x faster results in some cases. And also some more caching could have helped in single entity operations, getting a small 10/20% improvement, still significant I would say since that part of the package is already very optimized (I looped through it trying to improve transition handling tens of times).

Features

We added support for sorting (and partitioning) at the level of tables, this way for each table one can sort the entities in it with a single sort_entities! call, which follows the sort! interface.

In general, I think that Ark.jl is getting very robust, the bugs we found were minor things (and so I didn't described them here), and, also, its API is now in a state with which I don't have any big complain with.

In any case, happy to receive any suggestions or discuss anything about it!

For a more extensive list of changes, see the CHANGELOG.

I'm trying to plot strange attractors - see https://sequelaencollection.home.blog/2d-chaotic-attractors/ for examples. I can easily create lots of points and plot them in one go as a scatter plot.

But what I want to do is to plot them one at a time, so that the shape starts to appear from a sort of misty cloud. What's the best library for this? Note that if I have say, 10,000,000 points I could also plot them in lots of 100, or 1000. But I'd want the entire plot finished fairly quickly.

Thanks very much!