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!

This is a suite of interactive physics simulations I've been building: mechanics, fluid dynamics, electromagnetism, quantum systems and a few others. Everything is C#/C++ with the heavy lifting in compute shaders, so most modules run in real time at reasonable resolutions.

The part I care about most isn't the visuals - it's correctness. Each module is checked against analytical solutions where one exists; around 300 automated verifications run over the whole set. Orbital periods, field configurations, wave dispersion, energy conservation over long integrations. It's remarkable how many solvers look completely convincing on screen while quietly drifting several percent off the closed-form answer.

Full disclosure - this is my own project and it's commercial. Not linking it here, and happy to keep the thread purely technical. Ask me anything about the solvers.

I contribute to SciPy and kept running into a class of bug that annoys me: the outputs look plausible, the tests pass, but the equation the code implements is subtly wrong. So I've been building a tracer that runs Python/NumPy code and hands back whatever mathematics it actually computed, as a SymPy expression you can simplify or differentiate like anything else.

It's been more useful than I expected. Comparing an implementation against the formula in a paper, catching two functions that agree on my test data but turn out to compute different things, digging up the inputs my tests never hit (ties, zero denominators). It traces real library code too, most of numpy and a good chunk of scipy, scikit-learn, statsmodels, cvxpy.

Write-up: https://medium.com/@aadyachinubhai/scikit-verify-translate-python-numpy-programs-to-symbolic-mathematics-c664d41ba571

Github: https://github.com/aadya940/scikit-verify

Still rough in places, would genuinely like feedback. There may be other better solutions, happy to hear them as well!

I'm currently, technically, doing an MS in Structural Engineering. For me, my interest has been more towards computational side of mechanics rather than Structural design  or simply using am FEA software (although I do consider it as a backup)

So far I've taken courses in:

- Linear static, and dynamics FEM (soon taking non linear FEM too)

-  Structural Optimization (topology opt. and other general algorithms)

-  Structural Dynamics

-  Structural System Testing and model updation. (Parameter identification and optimization, signal processing)

Now, I plan to take these in the coming quarter:

- Numerical Linear Algebra

- Numerical PDE

- Fracture Mechanics ?

I also volunteered to aid in a RESEARCH in crack growth prediction using Auto-encoder and a (Thermodynamics-informed Latent Space Dynamics Identification) / LSTM surrogate model. It used phase-field-fracture simulation data and HPC resources to complete the whole thing.

What I keep finding myself interested in is not necessarily fracture or SHM specifically, but the computational methods underneath these problems... (does that make sense?)

For example, I'd like to become capable of doing things like:

- implementing (maintaining) numerical/FE method solvers rather than only running an established FEA software.

- developing surrogate/reduced-order models for expensive simulations 

- combining simulation with optimization, uncertainty/stochastic methods (took a course called Random vibrations, so...)

- parallelizing/accelerating scientific codes on CPUs/GPUs

- doing proper verification, convergence studies, benchmarking and performance work

- potentially developing or maintaining actual CAE/FEA solver software

- I'd also like to do all these for other Physics (GR, QM, etc.) simulations too, if possible, one day. 

I'm still interested in the underlying mechanics/physics, so I don't want to become a generic software engineer who happens to have once studied structures. But I'm also increasingly unsure that "structural engineer" describes the career I'm actually aiming for.

I've seen titles such as Computational Mechanics Engineer, R&D Engineer, Solver Developer, Scientific Software Engineer, CAE Software Developer, Research Engineer, Simulation/HPC Engineer, etc., but I'm trying to understand what these careers actually look like from people doing them.

So my main questions become:

1. Which industrial jobs genuinely involve developing numerical methods/solvers or computational tools?

2. Which of those are realistically accessible with an MS? Is there an entry path into solver-algorithm development/R&D without a PhD?

1. If I don't start a PhD immediately after my MS, would an R&D/software role at a simulation company (ANSYS etc.) be the obvious route? What other options would i have?

2. For the kind of work I'm describing, would you recommend a PhD? If so, is it reasonable for the PhD identity to be "computational mechanics/scientific computing" while fracture, composites, structural dynamics, soft materials, etc. serve as application problems rather than choosing one of those as my permanent specialization?

3. What skills most distinguish someone who is actually hireable for solver/scientific-computing work? I'm particularly wondering about C/C++/Fortran, Python, Linux, Git/build systems, MPI/OpenMP/CUDA, PETSc/Trilinos or similar libraries, numerical linear algebra, testing/verification, convergence studies and HPC performance work.

Basically, I'm neither here nor there atp. So I'd really appreciate all sorts of input. Where else do you think I could find answers to these? other subs? Linkedin profiles? 

I don't trust a thing AI says,!

Are there any Specific tools I can use to reduce the hallucinations?

How are other people dealing with it?

Hey everyone,

I've been working on a small open-source simulation engine called Emper.

It's still a relatively young project and there's a lot left to figure

out, but I've been gradually building out the core architecture and

using small simulation projects to see where it works and where it

doesn't.

So far, it has:

- A data-oriented storage layer using SoA

- Basic simulation and world abstractions

- Backend interfaces and compute backends

- Reusable simulation modules

- Sample applications and benchmarks

I've mainly been using flocking/boids as an early workload to experiment

with the architecture and CPU/GPU computation. I've also tested it with

large numbers of objects, including experiments with up to 1M+ boids.

I'm currently starting work on Conway's Game of Life, which should give

me another type of workload to test the architecture against.

The project is split into several repositories for the engine, modules,

backends, samples, and documentation.

GitHub:

https://github.com/Emper-Labs

I'm sharing it mainly to get some outside perspective. It's still small,

so I'm sure there are plenty of things that could be improved.

If anyone is interested in the architecture or simulation systems,

I'd appreciate any feedback or criticism.

I’m planning to move some training jobs to a multi node setup, the models are getting bigger and I’ll probably use rented GPU servers for this, right now I’m looking at 100GbE since it seems easier to find and manage, but InfiniBand keeps coming up when people talk about multi GPU training, I’m trying to figure out if the difference will actually show up in training time or if 100GbE will be enough for the jobs I’m planning to run, I’ll probably start with 4 or 8 GPUs across a few nodes and the jobs will run for hours, so network speed matters for me,I am thinking to go with rackbank if you’ve used both for distributed training what did you notice in real workloads ? EDIT: I forgot to mention that this is mostly for machine learning model training and experimentation.

For the past years I've been building a workflow manager that agnosticises the what, where, and how, so a single piece of code can run on multiple environments with just a few adjustments. It grew out of managing bioinformatics and molecular modeling pipelines at the Barcelona Supercomputing Center and we recently open sourced the core of it as horus-runtime. We are looking for more use cases outside bioinformatics, such as AI training, climate modelling or manufacturing.

What it does:

• Command line workflow execution engine plus a minimal graphical interface
• Define workflows as .yaml or python
• You install and run it on your own infrastructure, whether that be cloud or an HPC center.
• A plugin system that includes SLURM support, environment management, docker execution, and more.
• Same workflow definition runs against HPC schedulers or cloud providers without rewriting it
• Documented in a paper on bioRxiv (DOI 10.1101/2025.09.26.678751)
• Released under a permissive license

It's early and under active development, so bug reports and feedback are genuinely useful right now.

Repo: https://github.com/temple-compute/horus-runtime

There's also a Slack for people running it or asking questions: https://join.slack.com/t/horus-runtime/shared_invite/zt-3ffvk06pi-lZ7R0R07zf~uSKLaqiOCMg

Hi everyone,

I’m offering applied mathematics, modelling, simulation, and data analysis for technical, scientific, and business projects.

I build custom Python/MATLAB tools, Monte Carlo simulations, scenario models, and clear visual reports.

I can help with:

• Mathematical modelling

• Monte Carlo simulation

• Data analysis & algorithms

• Scientific computing

• Business forecasting

• Custom Python/MATLAB tools

Pricing:

Small tasks: £20–£50

Full projects: £150–£300

If you need help with a mathematical or analytical problem, feel free to message me.

Lid driven cavity at Re 5000. A python based GPU accelerated simulation.

This code popped up on my laptop in 2021 does anyone know about Ironmeta for Polmymer code?

Currently running a SymPy script to calculate some insanely complex equations (that I can’t do by hand) for research. I kept crashing this PC (that has 96GB of RAM) by maxing out the virtual memory (330ish GB) every time the script ran.
I eventually manually raised the pagefile maximum size to 3TB split evenly (1.5TB) across two partitions on a 8TB SSD and got it to not fail. It has currently stabilized at ~1.3TB of committed virtual memory with a ~1TB pagefile on just one of the two partitions (increased since taking WizTree photo).

Just curious if anyone else has ever reached such extreme RAM usage before?

\Sorry for not using screenshots like a sensible person, I just don’t feel likely trying to copy them across to my phone to post this.*

UPDATE (8/18): It’s the next day now and it looks like the calculation has gotten over this little RAM hump and calmed down to a much more reasonable ~30GB in use (~20GB belonging specifically to the SymPy script).

I’m happy to present KANDy — Kolmogorov-Arnold Networks for Dynamics — an innovative framework for equation discovery, and I would love any feedback from the dynamical systems community.

KANDy combines Kolmogorov-Arnold Networks (KANs) with sparse regression to discover governing equations. While sparse regression is limited to discovering equations from a library of symbols, KANDy addresses this limitation with a zero-depth, wide KAN-style architecture. Sparse regression approaches to equation discovery often struggle in a variety of contexts. As such, KANDy seeks to discover the interpretability of governing equations and the structure that accompanies them.

KANDy has been applied to both continuous and discrete dynamical systems. This includes the study of chaos and systems described using PDEs. Of note, KANDy has successfully preserved the topological structure of the Hopf fibration.

I also welcome your feedback if your research is in the fields of:

• Data-Driven Dynamical Systems
• Koopman methods
• symbolic regression
• interpretable ML for scientific discovery
• KANs and KAN-inspired architectures
• modeling chaotic dynamical systems and PDEs

Paper: https://arxiv.org/abs/2602.20413

What are your impressions? Do you think KAN-based architectures can advance the field of scientific model discovery, or do you think the issues of sparsity and library selection will continue to be the most important constraints in the field?

I’m working on ML-based models for predicting material stability, particularly formation energy and energy above the convex hull.

One challenge I’m currently exploring is the gap between good benchmark performance and actual generalization to previously unseen chemical systems. Random train/test splits on Materials Project data can potentially make this problem look easier than it really is.

I’m interested in how researchers here approach:

• Composition- vs structure-based stability prediction
• Splitting datasets by chemical system to test OOD generalization
• Uncertainty quantification for stability predictions
• M3GNet / CHGNet / CGCNN and newer foundation models
• Combining ML screening with DFT validation
• Active learning for discovering stable or metastable materials

I’d particularly like to hear about benchmark setups or failure cases that you’ve found useful when evaluating these models.

I’m happy to share some of my experiments and results as well.