81
Part of @r_channels @reddit2telegram Broadcasts messages from the Julia programming language subreddit: https://www.reddit.com/r/Julia/ For discussions on Julia language, join @julialang_org
"Write a simple neural network using the Julia Language" from chatGPT
https://redd.it/1xptafa
@r_Julia
Looking forward to learning a new language :)
https://redd.it/1xn3z9h
@r_Julia
How do I get around this "juliaup needs to modify a number of files?"
I do have (a version of) julia and it is running on my windows system. But on my mac, I tried to "upgrade" to the latest version. And it seems to be stuck on ths needing to modify thing. Is there a simple solution? Thanks
https://redd.it/1xjybvk
@r_Julia
Help needed in migrating from MATLAB project to Julia
Currently, I have a large repository of MATLAB code related to some Radar processing ([https://github.com/roopeshor/Radar-Signal-Processing](https://github.com/roopeshor/Radar-Signal-Processing) ). I want to try out how Julia performs in this task. However, the current architecture classifies functions into different folders. In MATLAB, a function in a folder `+a/fx.m` can be simply accessed with `a.fx()` anywhere within the folder. However replicating such a system was extremely difficult for me due to the import system. My current idea is to organize each folder into modules and then link them all in one large module. But that approach failed. My situation is following:
* `io/reader.m` uses struct definition in `structs/Data.jl` (which was actually a classdef in MATLAB)
* `struct/Obs.jl` uses reader function from `io/reader.m`.
* functions in `algo` folder uses `struct/Obs.jl`.
* All functions in `algo` folder need to be packaged in single module `algo`.
* All functions in `io` need to be packaged in single module `io`
Is there some way to organize the code similar to Matlab? Current implementation with hierarchical organization tends to produce either cyclic dependencies or double import.
I dont know if its a big ask, But any help is appreciated.
https://redd.it/1xhmwyb
@r_Julia
How to make a GUI in Julia? Recommendations?
Hi I'm making a package for visualization and analysis of computational chemistry results. I need interactive graphs that allow me to select atoms, highlight bonds, etc, and toggle visualization options using buttons or sliders. I don't have experience making a GUI, although I managed to make a composite figure with a slider and observables that allow me to switch structures from a trajectory file. But don't know how to go beyond that to an acceptable GUI. Any advice on where to get started is appreciated!! Thank you!!
https://redd.it/1xfjbn9
@r_Julia
My new wall decoration
https://redd.it/1xdff95
@r_Julia
PerfChecker.jl tutorial series: benchmarking, profiling, and reproducible performance checks in Julia
Hi everyone!
I work on **PerfChecker.jl**, a Julia package for running repeatable performance checks and comparing results across implementations or package versions.
You define the operation to measure and how to verify its correctness. PerfChecker coordinates benchmarking, profiling and analysis tools—including BenchmarkTools, Profile.Allocs and JET—and saves the results for inspection, comparison and sharing. You can use it to investigate performance problems and prepare regression checks for CI.
I’ve put together an English tutorial series with an introduction and five chapters covering:
* Installation and a first run.
* Benchmarks, profiles and analysis tools: what they’re useful for and how to interpret their output.
* Reproducible suites, correctness checks and CI configuration.
* VS Code, terminal, Web and Pluto interfaces, plus exporting and sharing results.
* MCP advice, reviewed code changes and bounded investigations.
The walkthroughs use real interfaces and recorded results. The emphasis is on understanding what each tool tells you and choosing a useful next step.
[YouTube playlist](https://www.youtube.com/playlist?list=PLFftPhrXlLp0)
[Source code and issues](https://github.com/Mirage-Interactive-Fr/PerfChecker.jl)
I’d appreciate feedback on getting started, interpreting results, and workloads you’d like to see covered. Questions, bug reports, documentation improvements and contributions are all welcome.
Thanks to the Julia community and the maintainers of the tools PerfChecker brings together!
https://redd.it/1x8civ5
@r_Julia
How I did Molecular dynamics on a peptide with my own code
https://youtu.be/SwXXO7a-9Z8
https://redd.it/1x71rcl
@r_Julia
Necro-Matcher - Early Access Trailer (A game written in Julia)
https://www.youtube.com/watch?v=qCFnIIHp1Yw
https://redd.it/1x555wr
@r_Julia
Calculus with Julia
https://jverzani.github.io/CalculusWithJuliaNotes.jl/
https://redd.it/1x4gpwk
@r_Julia
Contact mechanics in Julia, directly from the weak form
https://redd.it/1x3kpzn
@r_Julia
SimCore.jl & SimDES.jl: Discrete-event simulation with analytical queueing benchmarks, conveyor kinematics, and Makie visualization
Hi everyone,
I’ve been working on discrete-event simulation in Julia and wanted to share an early release of two packages: **SimCore.jl** and **SimDES.jl**.
* **SimCore.jl** provides foundational event scheduling primitives (`FutureEventList`, virtual clocks, and $O(1)$-memory streaming statistics).
* **SimDES.jl** builds on top of SimCore to model queueing networks, material handling, and physical conveyor kinematics.
* GitHub: [SimDES.jl](https://github.com/SouKot/SimDES.jl) | [SimCore.jl](https://github.com/SouKot/SimCore.jl)
---
### Motivation & Where This Fits in the Ecosystem
Julia already has great simulation packages, and I want to acknowledge them upfront:
* If you prefer **process-oriented simulation** (SimPy-style coroutines with `@resumable` and `@yield`), **[ConcurrentSim.jl](https://github.com/JuliaDynamics/ConcurrentSim.jl)** is mature and well-suited for that workflow.
* If your problem revolves around **agent-based modeling** with complex spatial interactions, **[Agents.jl](https://github.com/JuliaDynamics/Agents.jl)** is the standard and far more established.
* For clock-based discrete event generation, **[DiscreteEvents.jl](https://github.com/pbayer/DiscreteEvents.jl)** offers a clean, native approach.
**Why SimCore and SimDES?**
My work required a specific combination of needs that led me to build this framework:
1. **Automated Verification Against Queueing Theory**: I wanted the engine's test suite to continuously assert empirical simulation results against closed-form queueing equations ($M/M/1$, $M/M/c$, $M/M/1/K$, Pollaczek-Khinchine for $M/G/1$, open Jackson product-form networks, and Little's Law invariance).
2. **Physical Conveyor Accumulation (ZPA)**: In material handling, items have physical dimensions and cannot overlap. I needed deterministic 1D conveyor kinematics where items queue up behind obstacles (Zero-Pressure Accumulation), observe safety gaps, and respect optical sensor interlocks without needing a heavy continuous physics engine.
3. **Constant-Memory Streaming Statistics**: To run long simulations without blowing up RAM, `SimCore` integrates single-pass Welford variance, Jain-Chlamtac $P^2$ streaming quantiles ($P_{50}, P_{95}, P_{99}$), and Welch moving-average warmup detection in $O(1)$ memory.
4. **Decoupled Visualizations**: The core engine has zero graphics dependencies, but optionally connects to Makie (`CairoMakie` for vector reports, or `GLMakie` for interactive desktop GUIs with live observable streaming).
---
### Quick Example: M/M/1 Queue
```julia
using Pkg
Pkg.add(["SimCore", "SimDES"])
using SimDES, Distributions
# 1. Setup simulation world with an arrival source and single server
world = SimWorld()
source_id = register_zone!(world, ZoneConfig(name = "Arrivals", arrival_dist = Exponential(1.0 / 2.0)))
server_id = register_zone!(world, ZoneConfig(name = "Server", capacity = 1, service_dist = Exponential(1.0 / 4.0)))
connect_zones!(world, source_id, server_id)
# 2. Run simulation
run_sim!(world; t_end = 1000.0)
# 3. Inspect results
stats = get_zone_stats(world, server_id)
println("Utilization ρ: ", stats.utilization) # Expected ≈ 0.50
println("Mean System Time W: ", stats.mean_sojourn) # Expected ≈ 0.50
```
There is also an interactive physical conveyor example in the repo ([`examples/06_interactive_conveyor_makie.jl`](https://github.com/SouKot/SimDES.jl/blob/main/examples/06_interactive_conveyor_makie.jl)) that demonstrates dynamic package routing, optical interlock gating, and ZPA queuing in GLMakie (an animated GIF of this is also embedded in the README).
---
### Current Limitations & Honest Caveats
This is an early `v0.1.0` release, and there are several limitations worth noting:
* **Early API**: While the underlying queueing math passes all automated test suites, the public API may still evolve as we receive feedback.
* **Paradigm**: It is based on explicit event scheduling and state transitions rather than coroutine-based
Doom in Julia 100%
Hello friends, my name is Wagner (vagucs), and I've been working for a few months on porting the Doom generic to Harbour, which is a high-level xBase language. Having done that, I'm now porting it to other high-level languages. The goal is to port 100% of the Doom logic to high-level languages. I'm keeping the basics in C to use SDL2 in all of them; this can be substituted for the screen output the developer wants.
So far, I've done it for several languages: Harbour, PHP, Python, Node.js, Java, R, Lua, and now Julia.
I did a good part of the Harbour conversion manually to contextualize the AI so it knows how to "raise" the Doom level. This way, porting the source code to other languages at a high level became easy, and I'm doing it, despite my limited use of those languages.
I'm leaving this contribution for the community:
http://github.com/vagucs/julia\_doom
Video:
https://youtu.be/jITQFpVyCeA
Regards, Wagner
www.vagucs.com.br
https://redd.it/1wzel64
@r_Julia
45° really does max range — example Jupyter notebook using Julia
https://redd.it/1wxta0d
@r_Julia
MarkovJunior.jl version 0.3 is out for public use! Here is a second demo of it.
https://youtu.be/qp9h517rDII?is=b1PFWKnJ4my6Q_g8
https://redd.it/1v88ic1
@r_Julia
What are people building beyond conventional LLM agent architectures?
I'm working on a Julia-based AI system with its own behavioral processing, persistent state and dynamic code-generation capabilities. It can generate new Julia functions and incorporate them into its available execution tools.
I'm interested in what else is being developed in this space, particularly architectures that combine behavioral systems with dynamic execution.
I'd like to compare approaches and hear some serious technical perspectives.
https://redd.it/1xnxsku
@r_Julia
What are the advantages by using Julia rather than R or Python?
More often than not, at work, we are encouraged to create data analysis dashboards using a programming language. Some of my friends have suggested that I use Julia instead of R or Python. Can its libraries, similar to tidyverse in R or pandas in Python, be used to create innovative, useful, and aesthetically pleasing visualizations? What are its advantages? Excuse my ignorance
Thanks in advance!!!
https://redd.it/1xi6zxl
@r_Julia
When you think Julia's fast enough to make up for an inefficient algorithm
https://redd.it/1xh5g7n
@r_Julia
Building an open-source survival simulator in Julia: How do you model equipment wear-and-tear alongside daily energy use?
We're building an open-source simulator in Julia to stress-test off-grid community designs (solar arrays, water storage, heating) before spending real money on physical hardware.
The part I'm scratching my head over is handling wear and tear.
Daily energy and water use are smooth, continuous flows, and DifferentialEquations.jl handles that part smoothly. But real hardware doesn't degrade smoothly. Inverters overheat and pop, water pumps seize up after 3,000 operating hours, and someone forgets to clean a filter.
If you've built multi-year simulations in Julia, what's the cleanest way to trigger sudden mechanical breakdowns based on accumulated usage hours without slowing down the continuous ODE solver?
Keeping it simple and modular is key. Are there any good patterns or packages you'd recommend for coupling discrete stochastic events with continuous stock-flow equations?
https://redd.it/1xegd75
@r_Julia
The Julia programming language repository summary
https://redd.it/1xcn71e
@r_Julia
I accidentally a Julia-based inference engine that can run Qwen3.8-27B
(There's more to Luminal.jl than this, see the github link for more, but this post focuses on running Qwen3.8-27B)
### Serve Qwen3.8-27B (GGUF)examples/qwen35_server.jl serves a Qwen3.5 / 3.6 / 3.8 GGUF through an
OpenAI-compatible API (streaming chat completions, tool calls, reasoning
content), for harnesses such as opencode. Weights stay in the GGUF's own
quantization on the GPU (LUMINAL_GGUF_NATIVE=1; Q4KXL, about 17 GB), and the
model's MTP head drafts tokens for speculative decoding.
LUMINAL_GGUF_NATIVE=1 julia -t auto,1 --project=. examples/qwen35_server.jl \
/path/to/Qwen3.8-27B-UD-Q4_K_XL.gguf --max-seq=262144 --port=8080
-t auto,1: the server needs the extra interactive thread. The HTTP tasksserving ... when it is ready.--max-seq sets the context and the KV cache allocated up front (Float16,--mtp=<gguf> (a separate file--host, --name (the model id), --no-spec, --int8.http://127.0.0.1:8080/v1 (GET /v1/models, GET /health,POST /v1/chat/completions). For opencode, add an @ai-sdk/openai-compatiblebaseURL and the --name as the model id. Long prompts can--reasoning-budget=N limits the thinking: after N reasoning tokens the server<think> block with a short wrap-up and the model answers from whatthinking_budget (also thinking.budget_tokens,reasoning_budget; 0 = no limit). In opencode, put "thinking_budget": N in theoptions.LUMINAL_CKPT_EVERY), so a follow-up turn reprocesses only itsexamples/qwen35_gguf.jl <file.gguf> "prompt".
45° really does max range — example Jupyter notebook using Julia
https://redd.it/1x5r9o5
@r_Julia
October Headline: Julia Returns to the TIOBE Top 20
https://www.tiobe.com/tiobe-index/
https://redd.it/1x4i3pq
@r_Julia
juliaTDGL -- a 3D two-band TDGL solver in Julia
Hi everyone. I've been working on a solver for the geometric superconducting diode effect in two-gap superconductors (like MgB₂), and I just released v1.1.
It's a 3D two-band time-dependent Ginzburg–Landau solver with:
\- self-consistent vector potential (so screening and self-field are part of the model)
\- gauge-invariant Josephson voltmeter that counts vortex crossings
\- arbitrary 3D shapes from TOML files or a browser editor
\- a terminal menu to launch and track runs
v1.1 adds an implicit scheme for the Maxwell term, which gives \~3× speedup at κ=2 and \~100× at κ=25. Same onset brackets, voltages within 0.2%. A production-box run takes minutes on a laptop.
It's standard TDGL (not generalised KWT) on a Cartesian grid, and pyTDGL is better if you need unstructured 2D films. A multiband generalised version is the next step.
Repo: https://github.com/georgeotjg/juliaTDGL
Feedback and issues welcome, especially from anyone working on superconducting devices.
https://preview.redd.it/5zanhxougyuh1.png?width=1927&format=png&auto=webp&s=1b48d35d293f12183ecd831701314b5fa2979243
https://redd.it/1x3qwy8
@r_Julia
yielding. If your mental model relies heavily on SimPy-style generators, `ConcurrentSim.jl` might feel more natural.
* **Documentation**: More work towrads tutorials and real-world industrial case studies is required .
---
### Feedback Welcome!
If you work in operations research, queueing theory, industrial engineering, or discrete-event modeling, I would be very grateful if you could try running your models or take a look at the code.
Any feedback, critique of the API design, bug reports, or feature suggestions on our [GitHub Issues](https://github.com/SouKot/SimDES.jl/issues) would be immensely appreciated.
Thank you!
https://redd.it/1x0aiqc
@r_Julia
Molecular Dynamics with Julia: First peptide MD!!
https://youtu.be/-i6uyGg_PKQ
https://redd.it/1wzkhfs
@r_Julia
Nine small Julia programs, one per result, behind a book of the maths that shapes the world
I have been building a book of advanced mathematics where every formula keeps its originator's name on the page. The part that might interest people here is that no result in it is allowed to be a picture. Each one has to come with a small Julia program that recomputes it, and the nine machines are in the repo under site/machines.
They are:
\- galaxy_rotation.jl, rotation curves against the visible mass
\- eddington.jl, the luminosity where radiation pressure balances gravity
\- jeans_mass.jl, the mass at which a cloud collapses
\- schechter.jl, the galaxy luminosity function
\- hubble_tension.jl, the two measurements of H0 that will not agree
\- three_body.jl, the figure eight orbit
\- lorenz.jl, because it is the honest example
\- phyllotaxis.jl, the golden angle in a sunflower
\- rubik_group_order.jl, the cube group at 43,252,003,274,489,856,000
Each one is standalone, no package, runs from a terminal, and prints what it claims with the numbers attached. The rule i set myself is that a plate ships only if its machine reproduces the number on the page.
I would genuinely like review on the numerical choices: tolerances on the three body integrator, whether the Schechter fit should carry its errors on the page, and whether the cube group order should be a computation or a lookup. Repo is at github.com/Mascottz/Codex-Naturalis, machines are the only folder you need.
https://redd.it/1wy531b
@r_Julia
Setting up a monomer to build polymer chain with Julia
/r/comp_chem/comments/1v7o0h2/setting_up_a_monomer_to_build_polymer_chain_with/
https://redd.it/1v7z0gd
@r_Julia
TIL that Makie is pronounced “mah-kee”
According to the project README.md:
>The name Makie (we pronounce it Mah-kee) is derived from the japanese word *Maki-e*, which is a technique to sprinkle lacquer with gold and silver powder.
I fear I may never be able to stop calling it “MAY-kee”.
https://redd.it/1v8lt4x
@r_Julia
