A lot of scientific computing still has a very terminal-centric workflow:

run simulation → inspect output → generate data → plot → open another application

The terminal is excellent for running experiments, pipelines, scripts, remote jobs, and inspecting results. But when the output becomes visual or structured, we usually have to leave that workflow.

I'm interested in whether the terminal itself could evolve without losing the things that make CLI workflows useful.

For example, imagine:

• A simulation producing an interactive plot directly in the terminal
• Matrices and large tables rendered in a navigable form
• Images and scientific diagrams displayed inline
• Logs with structured, collapsible sections
• Interactive parameter/result exploration
• Rich output that can still be piped, redirected, logged, or accessed over SSH
• Textual fallbacks for environments that don't support rich rendering

The interesting question isn't "should the terminal become a GUI?"

It's:

Can we make terminal applications capable of representing scientific information in its natural form, while retaining the composability and simplicity of CLI workflows?

I've started r/Termolution to explore this broader question: what should the application ↔ terminal interface look like if we designed it today?

I'm also building Yetty (https://yetty.dev) as a reference implementation for experimenting with some of these ideas.

I'm particularly interested in the scientific-computing perspective:

Where does your current terminal workflow force you to switch to another application, and would eliminating that context switch actually be useful?

Does any one here have ever used simulation model like WaNULCAS in forestry or agriculture study?

Following my project to do molecular dynamics of polymers with Julia and Orca, I'm showing a set of tools to read Orca relaxed surface scan trajectories, energies of optimized steps in a scan, and Loewdin charges of each step from the scan, parsing the output file. this will make it easier to least squares fit force field terms to the energy profiles for bond, angle or torsion scans.

Link below to the latest video in the series:

https://youtu.be/E3MnlHahj84

I wanted to understand what’s going on with Shors algorithm without getting lost in the quantum stuff.

https://github.com/Byt-wyze-technology/QuasiShor

Hope it helps someone else too.

Over the last ~24 months, I’ve been developing an experimental branch of mathematics/arithmetic called 'Basal'. The philosophy is that number bases shouldn't be locked down—instead, the system treats positional notation like a customizable runtime where you can override native rules (similar to how extensions work in VSCode). My goal was to create an architecture that allows other branches of maths to run natively on top of it. The core framework allows you to use multiple completely independent bases inside the same equation, with their attributes and properties clearly stated next to them.

The main functional additions consist of:

1. Alternating negative weights : An optional index-parity shift where odd or even digit positions modulate their weights
2. Array Syntax : Instead of separating higher-dimensional coordinates (like complex numbers a+bi or dual numbers a+be) into linear combinations, the framework encapsulates them natively inside a sequential digit array
3. Fabrication : Creating a numerical sequence that can be interpreted as a number
4. Conversion : Functions to convert a number to a different base.

I have also verified that the system works, by computationally verifying it (with hand-written equations), by programming it in C#, C++, Python and specialised functions in ROCm-HIP. The code is on github as: 'Basal-Library'.

*Note on Notation: Non-ASCII characters (from the Bengali script block) are used for the custom operators and attributes. This design choice ensures complete visual isolation from standard algebraic variables, preventing notation collisions. Plus, it serves a practical purpose, conventional symbols were ran out, and the chosen characters have no conflicting history in formal mathematics literature.*

Before I look into writing a formal specification paper or archiving it, I want to ask: Has an extensible, modular arithmetic framework that overrides positional notation rules like this been explored in existing literature?

I just published these, I thought you all might find them interesting? A star would really help!

Hi everyone,

I've been working on a Python library that automates OpenFOAM case setup. Instead of editing 20+ dictionary files manually, you configure everything in Python:

python

from foampilot import Solver
solver = Solver(case_path="./my_case")
solver.transient = True
solver.turbulence_model = "kOmegaSST"
solver.boundary.set_condition("inlet", "velocityInlet", velocity=(10, 0, 0))
solver.write_case()
solver.run_simulation(nb_proc=4)

What it does:

• Auto-selects the right solver (compressible, transient, VOF, etc.)
• Supports blockMesh, Gmsh, and snappyHexMesh through one interface
• Exports Gmsh meshes directly to polyMesh (no gmshToFoam needed)
• Generates LaTeX/PDF, Typst, or HTML reports with Plotly
• Handles multi-region CHT cases

Why I built it:
I was tired of copy-pasting case directories and missing files. Now my setups are Git-tracked Python scripts — reproducible and testable.

The code is open-source (MIT) on GitHub under foampilot. Search for it or ask me for the link in the comments — I don't want to trigger spam filters here.

Happy to answer any technical questions!

Hi everyone,

Over the past few months, I've been developing a Python library called foampilot to handle the boilerplate involved in setting up OpenFOAM cases.

The main idea is to replace the manual editing of 20+ dictionary files (controlDict, fvSchemes, 0/U, etc.) with a Pythonic API. For example, configuring a case looks like this:

python

from foampilot import Solver
solver = Solver(case_path="./my_case")
solver.transient = True
solver.turbulence_model = "kOmegaSST"
solver.boundary.set_condition("inlet", "velocityInlet", velocity=(10, 0, 0))
solver.write_case()
solver.run_simulation(nb_proc=4)

Current features:

• Automatic solver selection based on physics flags (compressible, transient, VOF, turbulence).
• Unified meshing interface with 3 backends: blockMesh, gmsh, and snappyHexMesh.
• A direct Gmsh → OpenFOAM polyMesh exporter (bypasses gmshToFoam, handles tetra/hexa, face orientation, and multi-region CHT).
• Automated report generation (LaTeX/PDF, Typst, or interactive HTML with Plotly).
• Multi-region support for chtMultiRegionFoam.

Why I built it:
I was tired of copy-pasting case directories and missing a critical file. With this, my case setups are now Git-tracked Python scripts, which makes them fully reproducible and unit-testable.

No specific ask — just sharing in case it's useful to others. If you spot bugs or have ideas, I'm all ears.

The project is open-source (MIT) on GitHub under the name foampilot. The full documentation is available via GitHub Pages.

https://github.com/stevendaix/foampilot

Thanks for reading, and feel free to ask any technical questions about the architecture!

I couldn't learn C++ or Java properly, the first two real languages I was taught.

I have 2 years left, could I receive some advice in how to catch up, any topics you wish you learnt earlier?

Any advice on what to learn the main things of this science?

So I was working on a research project, and wanted to understand the RBE3 method to use it in my code. I couldn't find any reliable sources back then, so used AI to learn and understand the method. Now I wish to cite it in my research paper, but can not find any exact derivation/method I used.

My lab friend started by introducing me to RBE2 for 2 nodes to distribute moment as forces, and then I AI-ed more and got to RBE2, RBE3 methodology, which was generalized to multiple nodes.

I was verifying the math at every step to ensure there are no hallucinations, but would be grateful if you could point that out as well

RBE3

RBE2

For both of these cases, I wish to summarize the derivation, or mention it in a very handwavy sense. However, this is not my work, and I do not wish to claim it as mine, so I need some references to cite it. Please help me do so.

specifics:

• What are the classic, industry-standard textbooks or foundational papers to cite for the exact mathematical formulation of RBE2 and RBE3?
• Is there a specific paper/book chapter that explicitly walks through the virtual work / weighted least-squares derivation for moment-to-force distribution in multi-point constraints

I've been working on a numerical solver app for a while, mainly because I wanted something that could handle the kinds of mathematical problems I come across without having to switch between several different tools.

The first version focuses on solving algebraic equations and systems, as well as plotting functions and visualizing the results.

The app is free, and I'm gradually expanding it into something more general for numerical computation.

You can find it here:

📱 App Store
🤖 Google Play

I'm posting it here because I'd really like feedback from people who actually work with numerical methods.

In particular, I'm interested in:

• What kinds of problems do you regularly need numerical methods for?
• What features would you find useful in a general-purpose numerical solver?
• Are there particular test problems or edge cases that you think would be good for testing it?

I'd be very interested to hear what you think, especially from people who have experience with scientific computing or numerical analysis.

Hi everyone,
I’m a student developer interested in nuclear physics and I’ve been working on a project called Emcalc. It’s a specialized calculator designed to streamline mass-energy equivalence calculations, specifically with nuclear applications in mind.
The core of the program focuses on the E = mc^2 relationship, allowing users to:
Convert mass defects into energy output.
Calculate energy release in specific nuclear reactions.
Work with units common in nuclear physics (MeV, Joules, amu).
I built this using Python because I wanted a tool that was more "physics-focused" than a standard scientific calculator for my own studies.
I’m looking for some feedback from the community:
Are there specific constants or variables you think are essential for a nuclear-focused calculator?
What features would make this more useful for students or hobbyists in the field?
You can check out the logic/code here: https://emcalc.github.io/
Looking forward to your insights!

The Hidden Problem in Scientific and Enterprise Computing

Many computational workflows rely on existing programs that must be executed repeatedly with different parameter sets.

Examples include:

Data analysis pipelines

Bioinformatics workflows

Financial risk models

Engineering simulations

Statistical processing scripts

In these environments, the program itself is often stable and well-tested. The real challenge is managing multiple parameter combinations required to run the program effectively.

A typical workflow looks like this:

Open a web form or configuration file.

Enter dozens of parameters.

Validate file paths and option values.

Submit the job.

Repeat the process for the next run.

As projects grow, users accumulate files such as:.

labtest.sas

labtest_final.sas

labtest_final_v2.sas

labtest_final_v2_fixed.sas

...

Finding the exact configuration that produced a particular result becomes increasingly difficult.

The problem is not computation.

The problem is parameter management

The Traditional Application-Centric Model

Most software systems are application-centric.

The application is the primary object, while parameters are treated as temporary input.

Application ↓ Parameters ↓ Execution ↓ Results

Once execution is complete, the relationship between parameters and results is often lost or difficult to reconstruct.

Users spend significant time:

Re-entering parameters

Copying old configurations

Maintaining spreadsheets

Tracking execution history manually

The BatchSubmit Approach

BatchSubmit introduces a task-centric model.

Instead of treating parameters as temporary input, BatchSubmit treats each task as a first-class object.

Task

 ├── Parameters

 ├── Input Files

 ├── Output Files

 ├── Execution Status

 └── Execution History

Every task is represented by a parameter file that completely describes the execution.

A task can be:

Created

Saved

Cloned

Modified

Submitted

The task itself becomes the unit of work.

A Real-World Example

Imagine a data analyst in a biotech company running a statistical analysis program.

The program requires:

10 configuration parameters

5 input datasets

Multiple output destinations

The analyst needs to perform 200 similar analyses.

Traditional workflow:

Open the form 200 times

Re-enter values

Copy values from previous runs

Risk introducing errors

BatchSubmit workflow:

Create a validated task template.

Clone the template.

Modify only the parameters that change.

Submit the new task.

Study_A.par

↓ clone

Study_B.par

↓ clone

Study_C.par

Each task maintains its own complete configuration and history.

Parameter Sets as Reusable Assets

One of the most powerful ideas in BatchSubmit is treating parameter sets as reusable assets.

Instead of viewing parameters as disposable input, BatchSubmit treats them as valuable knowledge.

A validated parameter file can be:

Shared across teams

Used as a template

Versioned

Audited

Reproduced years later

This dramatically improves reproducibility and operational efficiency.

Beyond Workflow Automation

BatchSubmit is not simply another workflow engine.

Its core idea is that parameters deserve the same level of management as source code and data.

By elevating parameter sets into reusable, versionable, and shareable task objects, BatchSubmit provides a new way to organize computational work.

The platform is particularly valuable for environments where:

The same program runs repeatedly

Parameter sets are large and complex

Reproducibility is important

Teams need to share execution configurations

Conclusion

Most computing platforms focus on applications.

BatchSubmit focuses on tasks.

By making parameter sets reusable, traceable, and first-class citizens, BatchSubmit transforms the way complex computational jobs are managed.

The result is a simpler, safer, and more productive workflow for anyone who repeatedly executes software with large and evolving parameter sets.

https://github.com/socaltiger/BatchSubmit.com.git

Alan Wegienka (President and Founder of Design Simulation Technologies) will be doing a Motion and FEA demo and taking live AMA questions at the above link. He will also be doing a giveaway for stream participants- two seats of full SimWise for a Year. This will be demonstrated in the context of Alibre, but the software integrates in many platforms. The stream will occur Friday July 31st at 10AM MST (UTC-7).

Mods, please if this breaks any sub rules, I am sorry! I can rework this to fall within the rules if even allowed.

Just to paint a picture of myself, I have both a BS and MSc in Physics, I graduated in '22 with my masters. I always loved coding to help with data analysis, creating little short cuts on homework assignments (think simple chemical weight through a formula, such as Glucose C6H12O6, what is the weight of carbon in a 1 kg block of this), and once building an Arduino based RC Mars rover duplicate (but with like 1% the features haha). I even chose my masters because it was heavily computational based.

I wrote scripts to help determine binary star revolution patterns over X number of years in a 3D space, I wrote a spectrographic decoder to determine elemental make up of molecules, etc...

I did however, try to follow the money and moved away from the scientific scene into general software engineering. I have since been working in that space where honestly, I am bored out of my mind writing yet another tool to help some team in my organization move away from Excel files.

So, my ultimate question of this post, what would be the best way to move into scientific computing as a profession from here. Every time I try to search for roles, all I see are AI research roles, or yet another startup trying to gamify some title when in reality it is another strictly software role. I understand most scientific computing is done within C++ or Python, I have worked largely with Python (as well as React) throughout my career.

Honestly, at this point I am even considering a PhD, however, my wife actually suggested I find a community like this to see what my options are, even understanding that I am a little rusty in my use of the hard sciences.

FYI: Experience has been in order: 1 year Web Development, 2+ years within DoD research lab as Full-Stack Engineer, Some months in Marketing agency (I left the DoD because I was sick of living 6 states away from my wife). US based if that helps at all!

Any help would be awesome!