Hey r/ScientificComputing !

I'm a physics engineeering student, and I spend a lot of my time writing numerical simulations and analyzing data.

Programming in C++ is enjoyable, but most of numerical computing libs in are just unpleasant to use. So I started building my own solution in my free time.

GitHub: https://github.com/mslotwinski-dev/NumC

Some of the things I built into it:

• You can write mathematical expressions naturally, like sin(x) * exp(-x), and differentiate or integrate them in a single line thanks to lazy expression trees.

• It has a built-in plotting engine, so you can display graphs in a native Win32 window or export them as clean SVGs ready to drop into a LaTeX report.

Of course, the project won't surpass the quality of professional libraries. Its goal is to be convenient and accessible for users whose passions lie more in math, rather than programming.

If you're using C++ for simulations, numerical methods, physics, or data analysis, I'd really appreciate any feedback.

Creating reaction energy diagrams with Matplotlib or other software manually is usually very time-consuming. Therefore, I created a Python package which can handle path drawing, numbering and layout automatically and has other useful features like image insertion or difference bars. It also features multiple drawing styles. Since it is based on Matplotlib, it remains fully customizable while still speeding up diagram construction significantly.

A minimal working example could look like this:

dia = EnergyDiagram() 
dia.draw_path(x_data=[0, 1, 2, 3], y_data=[0, -13, 75, 20], color="blue") 
dia.add_numbers_auto()
dia.set_xlabels(["Reactant", "IM", "TS", "Product"]) 
dia.show()

The package is available on PyPi and can be installed with pip:

pip install chemdiagrams

You can find the links to the project here:
GitHub: https://github.com/Tonner-Zech-Group/chem-diagrams
PyPi: https://pypi.org/project/chemdiagrams/
Documentation: https://tonner-zech-group.github.io/chem-diagrams/

I would love to get any feedback!

I had asked an experimentalist who studies ice physics to look into claude code for data analysis. 1) Within a week they were able to implement an open cv based end-to-end video analysis pipeline catering to their exact expectations. 2) They have figured out they can vibe code a FE model for their system to that end they have figured out meshing, FEniCSx solver setup and DOLFINx scripting. They are convinced they will never have to collaborate with a computational lab. What are your thoughts on this? Who will enroll in a computational science lab?

At first I just wanted to generate cellular automata and find interesting patterns.
Then I wanted to understand *why* some of them behaved differently.
So I built an observer.
Then an analyzer.
Then experiments.
Then evidence tracking.
Then predictions and mechanisms.
At some point I added a research director that decides what should be investigated next.
And eventually I realized that I had created so much research data that I needed an entire interface just to understand what my own program was doing.
That’s how ARCHON Studio happened.
I still find it slightly ridiculous that this started with:
**“Huh, cellular automata are pretty cool.”**
And ended with me building my own little computational research laboratory.
I regret nothing. 😹
It’s open source, so if anyone wants to poke around, break things, or run their own experiments, it’s on GitHub.ARCHON

During the process of building a system simulator I collected a bunch of ODE solver coefficients and put then now into a library. Including relevant metrics (A-stability, stiff accuracy, convergence order, cost, etc.). Besides being a handy overview of the methods out there, I also think it looks cool.

You can browse through it here: solvers.milanrother.com

And visit it on GitHub here: github.com/milanofthe/solvers

Hey everyone,

I'm starting an MSc in Computational Science and Engineering at TU Delft. I already work with C++ and Python.

Is Fortran still actively used in European research labs and industry (national labs, aerospace, automotive or scientific software houses like Siemens), or is it mostly legacy maintenance at this point?

Does knowing it make a real difference for PhD positions or industry roles, or is C++ plus Python enough? And if it's worth it, should I learn it properly or just enough to read and modify existing codes?

Thanks, any experience from people working in Europe is welcome

Hello,

The school I attend has a major called "Mathematical & Scientific Computation" and in the major it has 3 numerical classes where they use Pascal, FORTRAN or BASIC.

They also use MATLAB.

How viable is Pascal, FORTRAN or BASIC?

I'm building Egraph/ Symbolic libraries to do QM Chemical physics. There is a specific way I want to solve the problems which takes the symbolic expressions and compiles them into optimized numeric expressions the computer can execute.

At first I threw Fable to speed write up the library. It wrote the examples that I asked it to write and got correct results for what I wanted. I had a large write up on how to implement the library, do not implement the QM computations directly with C++... use the symbolic library to derive and compile the results.

Once I tried using the library myself to write up examples, I noticed that it was missing a bunch of features I'd ask it to build. Once I dug into the code I realized that the model had ignored my instructions and implemented boiler numeric algorithms instead. I then went through to iterate with the chat bot to implement my features and add in the symbolic interface I wanted originally.

Every time, it would fall back to the default way the community at large has implemented open source solutions with direct numeric solutions. It did not understand how to adapt the implementation to the novel method I was asking it for.

Further it had over complicated the cmake file and added every edge case under the sun for building the project. All of it unnecessary since I told it explicitly I wanted a header only library, not a unit link-able library + binaries which is the most popular way of doing it in the industry.

What explains this is that these bots have encoded through billions of dollars of training standard ways of solving problems. It does not understand what it's actually doing and when one needs something that falls outside the standard, they're better off writing the software by hand since they'll spend all their time micro managing the frontier models.

For CRUD apps and devops,... these frontier models are great because nobody gives a shit about how those are built. Those have standards that make little difference in the means of implementation. But with what I'm building which generally has little to no opensource implementation training data, this stuff falls flat on its face.

Sure you can solve millennium problems this way if you bruteforce a bunch of mathematical reasoning traces together to create a lean program to make a counter example, but I am much more skeptical of these frontier models and to me it seems this stuff has genuinely plateud.

Author here. Started a series working through classic iterative solvers for the 2D Poisson equation in Fortran here. This is actually the second post (the first one being on Jacobi). Here, I dig into a genuinely counterintuitive result: the convergence theory for Gauss-Seidel checks out (half the iterations vs Jacobi, confirmed numerically), but the actual wall-clock time is 4-5x worse. Turns out it comes down to a single line: updating the array in place instead of into a fresh buffer and the loop-carried dependency that introduces, which stops the compiler from vectorizing the loop at all. In an upcoming post, I'll actually show how an open-source static analyzer can help you figure this out, and how simple algebra can be used to unroll the kernel and get rid of this loop-carried dependency.

Worth flagging: this series is primarily pedagogical rather than a performance-tuning guide. The goal is walking through the interaction between convergence theory and hardware behavior, not squeezing out maximum throughput. The example happens to be in Fortran, but there's nothing Fortran-specific about the underlying issue. Any compiled language with a similarly aggressive optimizer (C, C++, Rust) would show the exact same loop-carried dependency and the exact same vectorization failure for an in-place Gauss-Seidel update. No fix in this post yet (that's coming in a follow-up), just the diagnosis.

I’m a student researcher in computational mathematics, and to me scientific computing has always meant things like Galerkin methods, numerical ODEs/PDEs, numerical linear algebra, iterative solvers, error analysis, applied functional analysis, that sort of stuff. Essentially continous mathematical modeling motivated by foundations in mathematical analysis. I was wondering, beyond just the academia environments and conferences, whether there'd be an online community for the field and that's why I came here.

But looking through this subreddit, I don’t really see much of that. Most of what I see is ML, neural networks, symbolic regression, random simulation projects, software libraries, etc. These things make sense in the broader notion of computational science, but the scientifc computing I and my peers call what we do is different, so I’m just wondering if scientific computing has shifted to mean something much broader than it used to and what the people here think about it. How do you all define scientific computing?

I work at a fairly large computing center where I support researchers & do education and training & some research into parallel computing.

On that last topic: https://theartofhpc.com/ Share and enjoy!

Hi! I’m really interested in computational biology, especially modeling biological and physiological systems. I’d love to work on mathematical models and simulations of the human body, maybe even develop digital twins someday.

I’m considering studying computer science, but I’m wondering if it’s a good starting point for this field.

For those working in computational biology, do you think CS is a good choice? Or would biomedical engineering be a better option?

I’d love to hear your thoughts and experiences!

I wrote an engineering-focused C++ guide aimed at scientists and engineers—feedback welcome. Please note that it is a work in progress.

You can find it here: The Engineer’s Guide to C++ — The Engineer's Guide to C++ 0.2 documentation

Source code for the book and c++ source is available here: lunarc/cpp_course: C++ Course Source Code

So basically I'm a physics undergraduate student. I got into physics just by pure curiosity and love, I couldn't see my self doing something else than physics, but the problem was that my whole environment, and that includes parents, older sibling (actually two), my physics teacher in senior year high school, and my friends, all of them were like that's not a good option but I did it anyway.

They told me that theoretical physics don't matter anymore (cause that's all they thought about it I guess and me too and that's actually what got me in and by theoretical I mean just equations in a paper or on a board). It was two years ago and to be honest they were a bit right, I couldn't see any job perspective other that a teacher or a researcher (or both at a uni) and even though I was willing to go into research, they would also tell me that it was a super competitive with not much places available, and I kind of acknowledged that too but really I couldn't see my self studying anything else at uni so really plunged without thinking.

Now starting the last year my undergraduate (French system is 3y of undergrad) I think I found what I wanna do and that enthusiasts me while doing physics also. last year I had a numerical method course in fall semester, it was all python, and they taught us how to solve linear systems especially the Ax=b using LU decomposition, Gauss algorithm etc and how to solve numerically ODE (Euler & semi-Euler method, Verlet algorithm) and I was bad at it, I hated programming back then I didn't see any charm in it basically because I just couldn't understand it.

I got out with a 2/20 from that course (I didn't have a PC back then), then for Christmas break I had got a PC and dedicated all of my time just learning python basics (it's fun thinking Guido Von Rossum developed python during Christmas break he was alone), then I moved to the physics part, and though the linear system resolution didn't excite me much, the ODE resolution on the other hand completely blew my mind as I realized I could solve (approximate) non linear ODEs and especially that pendulum equation I knew since senior year high school that we only solved it for small angles completely and that blew my mind away, then I spent the following days solving all the ODEs I knew (from electricity to classical mechanics). for the resit exam I got the pendulum and smashed it then I really fell in love with physics programming as it also helped me grasp some details I missed in understanding them.

During the spring semester I enjoyed solving all my physics tutorials numerically (when there was a differential equation) but then one day I stumbled upon a Master degree on the internet presented my university and then I saw the light, a physics master that teaches you the computer in order to train computational scientist and physicist. I talked to a young teacher (as they are really nicer and have less responsibilities) if he could propose me an internship project and that's what he did he gave me DLA & KMC implementation and added a single constraint, no AI. I was cool with it. during that month I really helped me reinforce my new acquired abilities as I would be stuck with a single problem for hours, debugging the code and stuff. During that month I discovered Stack Overflow , stack exchange and reddit, I started asking questions and somehow, trying to explain my problem to others sometimes helped me find a solution to it and sometimes I would receive a response hours later and used that time in between trying to solve it (instead of just asking a LLM and getting dozens of lines of codes instantly).

Today I really enjoy learning programming, after the internship I started learning C++ and dived into the world of pointers, memory, and data structures.

In short, I see a real world use to my physics path now outside of academia and I'm really happy knowing that if one day I'm tired of research or don't have my place in it, I could go work as a computational scientist in the industry.

PS: I put the code I developed during my internship on GitHub but ashamed to show it to anybody, another constraint I had was to right the code only in functions and I really didn't knew how they worked fundamentally that means I could write and I wrote 700+ lines of code only in functions not knowing what I was doing (if that doesn't proof the existence of God 🙄️), A week after the internship I took a glance at it and I was ashamed as I declared every variable as global 😆️ I wonder what my tutor was thinking about when I presented that garbage.

Nonetheless the second part (KMC) was a bit better as I distinguished local from global variable but I didn't knew unpacking arguments when a function would return more that one variable.

That's my story from the day I stepped into physics at uni till today! I was more of a blog format, I'm happy if you enjoyed it, and excuse my English, I'm not a native!

I'm working in the field of particle based simulations. To save the results of our simulations we are interested in: per particle properties, per step properties and some general system properties.

One would assume, it is not to difficult to agree on a common format to do that but unfortunatley people are doing this for decades and no one is doing it like the others. Therefore, many different formats have emerged over the years and many tools try to handle them. Altough most of the data is numeric many formats are plain text whilst others are compressed. Here are two tools that can read some of the format https://chemfiles.org/chemfiles/latest/formats.html#list-of-supported-formats and https://wiki.fysik.dtu.dk/ase/ase/io/io.html . Even a short look shows the insane amount of formats available. Luckily some people thought about this problem and developed a standard, which is compressed (HDF5) and almost universal, e.g. can replace the other formats https://h5md.nongnu.org/h5md.html but if you check these two tools you won't find it. Only a few tools can write H5MD.

I wanted to give it a try and used the tools above that can read most of the files to import / export to a HDF5 / H5MD database. It was suprisingly easy in Python to import and export to / from H5MD files. So I wrote a package that can do that and also supports advanced slicing and batching and even provides an HPC interface through dask. Check it out at https://github.com/zincware/ZnH5MD

I hope to make the live of everyone working in the same field a little bit easier and want to promote the usage of H5MD at all costs.

tl;dr (by ChatGPT)
Hey folks, let me tell you about the absolute nightmare that is dealing with particle-based simulation data formats. It's been decades, and people are still using all sorts of different formats to save their results. It's a hot mess, I tell you. But fear not, because I have the solution - ZnH5MD!

I plan to write a dissertation on "combinatorial SIMD programming," i.e. SIMD programming for non-numeric applications, i.e. those that have strongly data-dependent control flow and little to no numerical components. It'll be fun!

To kick things off in this new subreddit!

I wanted to advertise the scientific computing and scientific machine learning libraries that I've been building. I'm currently doing this full-time at Google X, but this started as part of my PhD at the University of Oxford.

So far this includes:

• Equinox: neural networks and parameterised functions;

• Diffrax: numerical ODE/SDE solvers;

• sympy2jax: sympy->JAX conversion;

• jaxtyping: rich shape & dtype annotations for arrays and tensors (also supports PyTorch/TensorFlow/NumPy);

• Eqxvision: computer vision.

This is all built in JAX, which provides autodiff, GPU support, and distributed computing (autoparallel).

My hope is that these will provide a useful backbone of libaries for those tackling modern scientific computing and scientific ML problems -- in particular those that benefit from everything that comes with JAX: scaling models to run on accelerators like GPUs, hybridising ML and mechanistic approaches, or easily computing sensitivies via autodiff.

Finally, you might be wondering -- why build this / why JAX / etc? The TL;DR is that existing work in C++/MATLAB/SciPy usually isn't autodifferentiable; PyTorch is too slow; Julia has been too buggy. (Happy to expand more on all of this if anyone is interested.) It's still relatively early days to really call this an "ecosystem", but within its remit then I think this is the start of something pretty cool! :)

WDYT?

In the early 1980s, when personal computers first appeared, my colleague George Kelley and I were plasma physicists studying nuclear fusion. Mainframes had packages like DISSPLA™, but desktop PCs had primitive graphics and zero tools for publication-grade scientific plots. To solve this, we founded Scientific Endeavors Corporation and created GraphiC, an independent procedural graphics library designed for research workstations.

Over the past year, I have completely modernized the engine for modern 64-bit platforms (GraphiC 2026), targeting Modern Fortran (2003/2008 with iso_c_binding), C99/C11, Python 3, and Java 22.

During the rewrite, several design decisions from the 1980s proved to be surprisingly relevant to modern HPC and headless simulation bottlenecks:

1. The Headless Simulation Bottleneck

Many scientific codes run on cluster compute nodes without X11, Wayland, or GPU access. Typical modern workflows often shell out to Python/Matplotlib via pipes or CLI calls. While Matplotlib is expressive, it carries a ~350 ms cold-start penalty and a 300+ MB dependency stack (NumPy, FreeType, Pillow, GUI backends). If you are running an iterative solver and want to dump an in-situ diagnostic plot every few time steps, this latency becomes a noticeable bottleneck.

GraphiC was built with zero external runtime dependencies—it compiles purely with standard C headers and links against only -lm. Cold start is under 2 milliseconds, allowing it to be called directly inside MPI loops without disturbing compute throughput.

2. Algorithmic 3D Hidden-Line Removal vs. Z-Buffers

Most modern 3D plotting relies on OpenGL/Vulkan z-buffering or painter’s algorithm sorting. For publication vector output (SVG/EPS), polygon sorting often creates sorting artifacts, intersecting edge cracks, and bloated vector file sizes.

GraphiC uses an exact 2D horizon-matching algorithm (Wright's mathematical horizon method) for 3D meshes:

• It computes silhouettes and mathematical horizons across lines rather than rasterizing triangles.

• The output is clean, resolution-independent vector lines with true occlusion, resulting in tiny SVG files (~50 KB) that scale infinitely for journal papers.

3. Native Vector Typography & Hershey Fonts

To completely eliminate dependencies on system font servers or FreeType, the library includes 23 vector Hershey stroke font plates (including Greek, Math symbols, Gothic, and Cyrillic) along with native TrueType parsing. Because vector glyphs are rendered directly as strokes, text scales perfectly across all vector backends without missing glyph warnings.

4. Specialized Engineering Coordinates

Beyond standard Cartesian, log, and semilog plots, scientific work often needs specialized coordinate transformations that are cumbersome to implement from scratch:

• RF Microwave Smith charts (reflection coefficients and impedance circles)

• Chemical ternary equilibrium phase diagrams

• Multi-axis independent Y scales

• 2D velocity vector fields and cylindrical Bessel functions

5. Real-Time In-Situ Plotting

Because the rendering pipeline has virtually zero latency, GraphiC can display live data streams across multiple plots concurrently as they are computed. Rather than waiting for a job to finish before inspecting output files, you can watch solver states in real time—enabling you to abort diverging runs early and debug boundary conditions on the fly.

I’ve put together an interactive showcase of the SVG outputs, compiler benchmarks, and made the complete 190-page technical User Manual freely downloadable for anyone interested in the algorithms, coordinate systems, and API design:

🔗 Technical Overview & Free Manual: https://jamesrome.com/GraphiC2026

I would be interested to hear from other computational scientists: How do you currently handle in-situ visualization or vector figure generation directly from headless compute nodes?

(Full disclosure: I am the original co-author and developed this modernized release.)

I have a CS undergrad degree but I'm very interested in algorithms that are core for cutting-edge scientific or technology development.

Things like robotics, DSP, scientific computing, foundational deep learning, computational biology/neuroscience/etc. all sound really cool to me, but I don't know if they are realistic career paths with my CS background.

Everyone says that it's the PhD domain experts (physicists/biologists/EEs), or mathematicians that come up with the algorithms themselves. For the actual implementation and optimisation, I've heard mixed things.

Some people say that CS people will do this as the PhD domain experts write shit code (not my words!). Others say that they do it anyway, not the CS person, where instead the CS person will just at most call an API and focus on the systems integration & deployment.

APIs & deployment is cool and all, but I don't find doing that enjoyable. I'm much more interested in the underlying maths & algorithms themselves. I do enjoy a bit of low-level programming & code optimisation, but I want to be the guy who comes up with the_algorithm itself.

But as of 2026, AI can generate 80% of merged pull requests, solve math olympiad problems and even possibly Navier fucking Stokes. It feels pointless to be someone who specialises in inventing numerical algorithms, or optimising compute kernels, given that these both are closed ended problems with very clear optimisation metrics.

Scientific computing is already a niche field, where (apparently) it's the PhD domain experts, not the software engineers, who do most of the core implementation. With AI now, the scientists that are shit coders perhaps don't need a programmer at all.

So what room is there at all for a CS person like me in the field? Implementation, that's supposed to be my strength? Automated. Being the one who comes up with the algorithm? Also automated.

So then what will be left are just the physicists/biologists/etc? And the mathematicians & programmers are just done?

It feels like shit because I don't enjoy most of SWE work and working on core algorithms is one of the big things why I did a CS degree in the whole place.

But nobody told me that that's kind of a lie, in which you want to come up with algorithms? Oh fuck you, sorry, you're looking for "computational science", and what we do here instead is APIs, Docker, Javascript, C#/Java, Databases, Kubernetes & C++ and writing bytes to registers if you're lucky.

And the "computational science" here is done by the scientists, mathematicians or even engineers, and they can program anyway so fuck you with your CS degree, we don't need you, good luck getting a job doing this and fuck you.

So I discover one of things I've dreamt about, learn that my degree doesn't really "do it" because of stupid namings, learn that it's niche as fuck, and now AI might automate it crushing the small chance I had.

What should I do? Do I have to become a physicist/chemist/neuroscientist/etc. to have any hope? Are those computational fields cooked? I'm at a loss here.

Hi all!

I recently built a small C++ project to solve the generalized heat equation in 2D rectangular domains, mainly as a way to better understand PDE solver design and experiment with separating between spatial discretization and time integration.

The architecture of the project is modular:

- Spatial discretization (currently finite differences with Eigen sparse matrices)

- Time integration (Explicit/Implicit Euler, Crank–Nicolson)

The idea is to make it easy to plug different methods in each part (I’m planning to add finite elements soon). There are also a few example simulations (moving heat source, colliding pulses, etc.) with GIFs in the README.

I’d really appreciate some feedback, especially on:

- The overall design/architecture

- Performance considerations

- Whether this approach makes sense vs more template-heavy designs

Hi,

I have a current implementation of an implicit finite difference scheme for a PDE system in regular numpy and accelerated with numba's njit wherever possible. The resulting nonlinear system F(x) = 0 from this I solve with scipy's newton_krylov which is impressively fast and it's nice that it can avoid building the Jacobian for a system that can get quite large.

Anyway, I got the idea to try rewriting everything using JAX since in principle it should be an easy way to access GPGPU computing. Everything is more or less fine, but I found the ecosystem of JAX-based non linear solvers quite limited, esp compared to scipy, and all of them seem to build the Jacobian internally which eats a lot RAM and slows down the computation. Handrolling my own Newton-Krylov using JAX's jvp and gmres capabilities works okay, but it's not as finely tuned (preconditioners and such) as compared to the scipy version.

So my question is: does anyone know of a jax-based library that can provide a good implementation of a Jacobian free solver?

Is it just a wider grid search on a very powerful compute?

recently, I made a GPGPU project to help anyone simulate pretty much anything using python. Its available on pypi, its called hyperstellar(download it via pip "install hyperstellar" on windows and linux), so to see how far I could go, i simulated a clackhole using actuall physics! Its only 200 lines of formatted code in python. More examples at: https://github.com/jabariaiden/hyperstellar/tree/main/examples

Thanks for the support!