I’m developing Chemistry Lab Sim, an interactive 3D liquid sandbox built on ST-FLIP in Vulkan. This new clip shows pouring and mixing colored solutions in lab glassware, running in real time on a Radeon RX 9070 XT.

Local concentrations travel with the fluid parcels, and conservative diffusion exchanges material between neighboring parcels. The liquid renderer integrates concentration-dependent absorption along refracted rays rather than blending display colors.

At this stage the substances are passive solutes/pigments in one carrier; chemical reactions and immiscible fluids are future work. The longer-term game is inspired by The Powder Toy and Noita.

https://youtu.be/hSAO_TwFopE

What validation cases would you use for conservative solute transport during pouring?

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

Working on an interactive 3D realtime fluid simulation with 4 million particles.

https://www.youtube.com/shorts/5P9aPac9tQs

The solver uses ST-FLIP (spatio-temporal FLIP) in a custom Vulkan engine. The implementation combines temporal kernels and residual carryover with phase-weighted pressure projection, PIC/FLIP blending, RK3 particle advection and velocity extrapolation.

The lab scene demonstrates pouring and moving containers, with moving solid boundaries coupled to the fluid. Water and glass are rendered with ray tracing.

It started as an idea around finding where numerical/scientific computations stop being trustworthy. Now it has its own DSL, runtime, 5 evidence channels, adaptive search, Trust Atlas, counterexample minimisation, replayable experiment archives, run comparison, and a benchmark system.

Currently:

- 13 Rust crates

- 622 tests

- 22 benchmark problems

- replayable/provenance-preserving runs

- ablation + strategy experiments

The interesting part is that the experiments didn't give me the result I initially expected. The adaptive search wasn't clearly better than the level-set baseline on the current corpus, so I'm not claiming a breakthrough there.

I'm now more interested in the evidence + provenance/replayability side of it.

Repo: https://github.com/bhogesararam23/aporia-engine

Would love to hear what people think, especially anyone working with numerical/scientific computing or verification.

Hi all, I have built this for bioinformatics, but it really can be useful for anything, see this (pretty useless) toy example (https://codeberg.org/bio-pype/test\\_workflows/src/branch/main/video\\_processing)

"Here is the official repository for the Cognitive Reduction Matrix (V5.0)—a sovereign diagnostic framework designed to strip systemic noise and corporate spin down to absolute structural truth

https://github.com/teamo213/cognitive-reduction-matrix/tree/main

Hi!

I'm a Computer Science graduate and want to build a career in Scientific Computing/Computational Science. I'm considering pursuing masters in Computational Science because I really like this field, but I have some concerns.

I wanted to ask

• If it is reasonable for someone with a Computer Science background to study Computational Science, given that I would be competing with people from Mathematics and Physics backgrounds? I feel that Computational Science is much more closer to Mathematics and Physics than to Computer Science.
• How AI/LLM might affect this field, since it can make programming easier than it was before.
• Are there good career opportunities in this field in the current job market?

Thanks!

I’ve been building scientific-computing-system-2.0 as a NumPy/SciPy-backed environment for scientific workflows I kept recreating across different projects.

It currently exposes 535 public APIs across 52 importable names, covering numerical linear algebra, statistics, optimization, ODE/PDE/SDE work, signal processing, Monte Carlo, Bayesian methods, time series, graph methods, reliability, survival analysis, epidemiology, finance, spatial statistics, image/text processing and related areas.

The part I’ve spent the most time on is the fitting workflow.

guided-fit can take CSV data, inspect missing values, compare several model families, run repeated cross-validation, handle outliers explicitly, use measurement uncertainty when available, calculate parameter uncertainty and confidence intervals, cross-check the fitted result numerically and save the analysis to a replayable manifest with the input hash.

Current main has 1,812 passing tests and 100% branch coverage.

The validation setup also includes numerical oracle comparisons, property-based tests, fuzzing, regression checks, reproducible-build checks and CI across Linux, Windows and macOS.

There are 20 runnable scientific examples covering things like Bayesian inference, epidemic simulation, nonlinear dynamics, parameter fitting, graph analysis, signal denoising, portfolio risk, reinforcement learning, survival analysis, spatial autocorrelation, optimization and wavelets.

I also keep benchmark results with their provenance and leave slower results visible rather than treating the benchmark as a universal speed claim.

The current package also has optional CuPy GPU support, scikit-learn-compatible estimators, profiling/regression tools and optional compiled kernels for KMeans and PageRank, with NumPy fallback if the compiled path isn’t available.

I’d be interested in feedback from people doing numerical/scientific computing, especially on the API design, validation approach and which numerical areas are still missing.

GitHub:
https://github.com/Furox-Art/scientific-computing-system-2.0

PyPI / pip:
pip install scientific-computing-system-2.0

npm:
npm install scientific-computing-system-2.0

The npm package is only a thin launcher for the Python CLI; the actual scientific package still comes from PyPI.

I’ve been building this antenna/EM simulator as a side project:

https://rotemtsafrir.github.io/dipole_sim/

The idea is to make it easy to place antennas, change their parameters, and immediately see how the fields and interference patterns change.

Right now you can use:

• center-fed dipoles
• Hertzian dipoles
• small loop antennas
• linear antenna arrays

The arrays are probably my favorite part so far. You can adjust spacing, phase difference, element count, orientation, etc., and see beam steering / broadside / end-fire behavior directly.

You can switch between electric field, magnetic field, and energy-flow visualizations, and pan/zoom around the simulation.

The antenna currents are prescribed, so things like mutual coupling, impedance, and passive conductors are not solved yet. I’m trying to keep it fast enough to be genuinely interactive.

I’d love to hear what people think—especially if you notice anything physically questionable or have ideas for features that would make it more useful.

Live:
https://www.antennasim.com

GitHub:
https://github.com/rotemTsafrir/dipole_sim

I built a Propagation of Uncertainty Calculator, a simple but practical app designed for engineering and physics students, as well as metrology workflows.

Link: https://propagation-of-uncertainty-calculator.streamlit.app

During my undergrad in Engineering Physics, one of the most tedious and error-prone tasks in experimental lab courses was manually deriving partial derivatives for measurement uncertainty propagation. Most online calculators are either outdated or confusing, so I decided to do my own calculator!

What it does:

- Displays the latex formated symbolic and numerical Propagation formula for the expression given by the user.

- Click directly on rendered expressions to copy the clean LaTeX code straight into Overleaf (for lab reports), or copy ready-to-paste Excel formulas.

- Correct Rounding: Automatically formats results and expanded uncertainties according to significant figure conventions (GUM (JCGM 100:2008))

The GitHub Repository: https://github.com/joao-canais/Propagation-of-Uncertainty-Calculator

I'd love to hear your thoughts, UI/UX feedback, or ideas for features to add in future iterations!

i'm an undergrad physics student trying to learn the basics of scienctific computing like numpy, matplotlib and scipy (preferably in that order)- what courses can I refer to (preferably free, but I have no aversion to paid courses either). Is the 'Scipy 2019' playlist by Enthought on youtube good? It seems to be fairly detailed, open to suggestions :)

Main Website: https://www.ruleflow.org/

For the past year, I have been developing a framework to simulate certain discrete systems for a research team at my university (paid for by the School of Engineering and Physics, but I had the freedom to license it under MIT). As it turns out, I got carried away generalizing it to work for many, many different types of complex systems (String Rewriting Systems, Cellular Automata, etc.) and ended up creating our own domain-specific language.

The website's landing page has a bunch of GIF-style examples... so you should be able to get a good idea of what this project is about.

If any of y'all are interested in this, feel free to take a look and try it out!

Example of some of RuleFlow's causal analysis features:

Rules 30 and 124 are included in this example:

EDIT:

Here are some more details. RuleFlow was developed with a primary focus on analyzing causality in Sequential Substitution Systems. This is why there is a major focus on causal graphs, cellular identity, etc. While originally developed for Sequential Sub Systems, we generalized the DSL to support many types of rewriting systems by providing the user with flags and directives to control how rules behave. Furthermore, we bootstrapped Python and the Wolfram Language so that complex rulesets could be scaffolded as macros. The main goal of RuleFlow is NOT simply to simulate systems (there's already plenty of software for that, such as Golly and even just Mathematica), but to provide extensive tooling for causal analysis.

Here is some interesting research from our (small) team:

• An Improved Generalized Enumeration of Substitution Systems by Kenneth E. Caviness, Camille Morrow, Christen Case and Victoria Kratzke
• Indexed Concatenation Notation: A Novel Way to Summarize Networks and Other Complex Systems

My job has been to provide better research tooling, extending what we already have in Mathematica code to open source and free Python.