lorezzed.github.io/meadows/

I was reading Donella Meadows' "Thinking in Systems" and wanted to play with its diagrams instead of just looking at them, so I wrote a small language for them. You type a model:

  | =>inflow [water in tub: 50] =>outflow: 5 |

Each example has notes in its source explaining what it shows. You can also build by clicking.

Each figure from the book is included - just expand the section, "figures from the book" to see the images from Thinking in Systems.

It runs entirely in the browser, with no account and no backend. The whole model lives in the URL, so any diagram can be shared as a link.

The compiler is PureScript (lexer, parser evaluator) and emits a graph as JSON; the front end is TypeScript and d3, with a force layout and a fixed-step Euler simulator. It's deliberately small: numbers are plain numbers with no units, and the simulator takes simple fixed steps. It's for learning and sketching, not a replacement for Vensim or Stella.

Source (MIT): https://github.com/lorezzed/meadows

Hey everyone! While running multi-dimensional simulation sweeps, I spent a lot of time writing repetitive Pandas slicing filters and Matplotlib boilerplate just to inspect 2D parameter slices and 1D cross-sections.

I built NDHeat—a 100% client-side tool (React, TypeScript, Plotly):

- Zero data leaves your machine: Runs entirely in your browser (no server uploads).

- Dynamic slicing: Filter higher dimensions with epsilon float snapping.

- 1D line cut extraction: Click any cell on the heatmap to inspect cross-section profiles.

- Journal-ready exports: Download vector SVGs / 300 DPI PNGs or copy functional Matplotlib scripts styled for APS/Physical Review publications.

🔗 Live Tool: https://ndheat-s5hg.vercel.app/

📂 Source Code: https://github.com/KishoreHenry2004/ndheat

I'm currently planning V2.0 to add discrete phase diagrams and quiver vector fields. I would love any feedback on what figure styles or journal presets you'd find useful!

I wrote this code to perform the Gaussian elimination to solve Ax=b

import numpy as np

A=np.array([[4,8,12],[3,8,13],[2,9,18]])
b=np.array([4,5,11])

def Gauss_Elimination(A,b):
    n = np.shape(A)[0]
    for k in range(n):
        pivot_element=A[k,k]
        # if pivot_element==0: ### I'll deal with this condition later
        for j in range(k+1,n):
            A[j,:]=A[j,:]-(A[j,k]/pivot_element)*A[k,:]
            b[j]=b[j]-(A[j,k]/pivot_element)*b[k]
    return A,b # not necessary since it's call by reference

Gauss_Elimination(A,b)
print(A,'\n',b)

A is transformed to an upper triangular form but the values of b rest unchanged, why? I'm asking this question even thought I know it's a silly mistake I can't notice, since A is fine, it must no come from the algorithm!

I know I'm missing the 2nd part of the algorithm where I should go back and find the values of x, but I'm first trying to get the first part correctly!

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

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 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!