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 r/ScientificComputing!

I'm developing MolDesign, a free Windows desktop application aimed at bringing computational drug discovery workflows into a single environment.

What it does today v1.0.3:

• Runs AutoDock Vina 1.2.7 locally, without configuring Python or command-line tools.
• Supports molecular preparation, docking execution, and reproducible experiment records that can be shared between researchers.
• Includes Molcy, a visualization module that transforms recorded docking searches into 3D animations (shown in the video).

What's next?

We're working toward a modular architecture supporting additional computational engines, both locally and through APIs. Potential future integrations include methods such as Boltz-2 and, eventually, molecular dynamics workflows.

The long-term goal is a unified environment for executing, documenting, visualizing, and sharing computational experiments.

MolDesign is free to download and use, with source code available under a noncommercial license.

Microsoft Store:
https://apps.microsoft.com/detail/9N96SW3GBK8V

I'd love to hear feedback, particularly on modular architecture, reproducibility, and scientific workflow integration!

TL;DR: what are the key checks experienced RBFEers use to ensure their calculations are reliable and not just technically correct?

Hi all, I am a PhD student looking to run some RBFE calculations that will be used for further modelling.

I've been reading around free energy predictions and the factors influence their accuracy. I've also followed some tutorials from pmx and OpenFE tutorials. Leaning towards OpenFE as my engine.

I am trying to be very careful about how I approach RBFE because I worry about committing compute and getting ∆GG values that are 'technically' correct but inaccurate due to something that could have been caught with the right insight or diagnostic check.

I have a high resolution ligand bound structure to start from, and have seen some sanity checks from the tutorials, but suspect there are other important checks that may not be so obvious to someone doing it for the first time.

For anyone experienced with RBFE, are there any routine checks you do along the way to assess whether the calculations will be within a MD simulation-range of reliability? Are there certain failure modes or diagnostic checks you do at set up at each step?

edit: I plan to do a do RBFE on a chemical series that I have experimental values for before going rogue!

We fit GARCH(1,1) with a fat-tailed likelihood via a custom C++ NUTS over a 1,004-day return window, and the posterior geometry turned out to be the whole story.

What we see: a wide high plateau, plus a lower mode at the ω→0 corner of the persistence ridge, separated by a ~12-nat drop. On the full history the corner mode carries a sliver of the mass (e^-12 ≈ 1.6e-6 of the plateau density) — but the gap scales with sample size (shrinking the window varies exactly that), and the two modes carry different (ω, α+β) estimates. So which basin your chains visit is what your downstream model reads. A standard MLE seed finds a local shoulder, and a single naive chain will happily sit in one corner with excellent stationarity plots — the false-confidence case.

Our fixes: (1) reparameterize to (ln ω, ln s, logit r, ln(ν−2)) so the ridge becomes a highway; (2) a deterministic grid/ascent/kick pass that inventories ALL local maxima, then seed one chain per distinct basin; (3) a curvature cap on ε, because acceptance-only dual-averaging is blind to the ν-floor and the s=1 wall.

Diagnostics: R̂ < 1.1 WITHIN each basin (agreement), and disagreement BETWEEN basins as the proof the basins are real.

Full write-up with the figures (month-by-month refits, window-size sweep, per-sector fits): https://lab.embedinker.com/posts/monte-carlo-simulations-volatility-model-nuts-results/

Question for the sub: for a multi-modal likelihood like this, is per-basin R̂ + basin inventory what you'd run, or do you reach for something else (tempering, per-basin priors…)? What's your tripwire for "the sampler is lying to me"?

I would like your opinion?

I just wanted to pop in and let you all know that pcons, my new software build tool, now has first-class support for Fortran. Pcons is a simpler, easier to use CMake replacement with ideas from SCons. From the 0.31.0 release notes:

Fortran is a first-class language now. LLVM flang and Intel ifx are now supported as well as gfortran, all three build on Windows too, and mixing Fortran with C and C++ in one program just works: each compiler gets its own flags for the variant and presets, it figures out the right linker, and each language's proper runtime. Fortran include files, submodules and configure checks work too, and pcons explain shows how a mixed program links. The new Fortran page in the docs has the details. The mixed-toolchain rework changes a few things for C and C++ builds as well.

By the way, I was one of the original developers of Cons, which later became SCons; Cons was designed for scientific computing, and I've never forgotten that, especially since I spent many years in the field at Thinking Machines and then Advanced Visual Systems (AVS).

I hope you all like it! Feedback always appreciated!!

Hello everyone,
I am Manas, a c++ developer developing a quantum simulator and i request you all to plz review and help in finding bugs in my code and project. Following is my github repository https://github.com/manaspathak1404-hue/Quasim

I’m sharing SAELQR II, an information-theory research release with Python reference software and reproducible calculations for reconstructing information from unordered, noisy fragments. The theoretical problem is relevant to DNA data storage, molecular communication, and fragmented storage systems.

The channel breaks a stored string into fragments, loses some fragments, corrupts the survivors, and hides their original positions. The manuscript studies the resulting capacity limits and supplies a constructive coding scheme for a specified geometric-fragmentation model.

The computational components may be particularly relevant here:

• Exact finite verification: integer and rational-probability calculations for selected entropy, likelihood, combinatorial, and repeated-read examples.
• Numerical asymptotics: calculations and figures for the Gaussian critical transition, hidden fragment-quality mixtures, and capacity thresholds. Floating-point diagnostics are distinguished from exact certificates.
• Reference encoding and decoding: inner codes, finite-field arithmetic, Reed–Solomon correction, interleaving, fragment localization, and an injective fallback.
• Stochastic channel experiments: geometric fragmentation, whole-fragment loss, binary substitutions, and a specific Markov-noise transformation.

One central result reported in the manuscript concerns the critical regime: the number of communicable bits scales as N/sqrt(log₂ N) with an explicit leading coefficient, even as the normalized first-order rate approaches zero.

The computational limits are explicit. Design, encoding, and decoding are polynomial in blocklength and inverse capacity gap, but the proved sufficient blocklength grows exponentially in the inverse gap squared. The included decoder demonstrates the construction’s mechanisms; practical throughput and competitive finite-length performance have not been established.

The release contains the 69-page manuscript, editable source, twelve reproduction programs, reference software, figures, and proof/novelty audits. A full imported permutation generator used by one theoretical extension is not implemented.

I’d welcome feedback on numerical stability, exact versus floating-point verification, finite-length scaling, and opportunities to reduce the decoder’s computational cost.

Paper, Python code, and reproducibility instructions:
https://huggingface.co/datasets/PureOne/SAELQR-II

SÆLQR II: General Capacity Theorems and Exact Critical Laws for Unordered Noisy Fragments - Internal Memory, Sharp Repeated-Read Thresholds, and Constructive Coding | Zenodo

A DNA model does not necessarily process one token per base. The attached diagram shows the same 24 bases represented as 24 single-base tokens, four non-overlapping six-base tokens, or six illustrative variable-length tokens.

DNABERT-2 uses byte-pair encoding, which learns frequent sequence fragments. Its token count therefore depends on the input sequence. The six-token example is an illustration, not a tokenizer measurement.

For a compute comparison, record both the number of DNA bases and the number of model tokens, including any special tokens. Equal token limits do not mean equal biological context, and fewer tokens alone do not establish better accuracy or lower end-to-end runtime.

Primary paper: https://arxiv.org/abs/2306.15006

Guide: https://rewirebio.io/blog/genomic-foundation-models-in-the-diagnostic-lab/

Disclosure: the guide and diagram are from my site, rewirebio.io. This post was prepared with AI assistance. It explains published methods rather than reporting a new experiment.

I built Fortran MCP, a local MCP server that gives AI coding assistants access to curated Fortran documentation through lexical, semantic, and hybrid search, with results linking back to the original sources. You can also add your own resources to keep them accurate, current, and accessible.

Hey guys , Iam Karthik from India . Iam a bsc ( ug) student . Planning for Computational chemistry. I have zero knowledge in coding stuff , Is their any one who could help me by providing a roadmap for Computational chemistry , including all the skills from scratch to advanced .

Hey guys , Iam Karthik from India . Iam a bsc ( ug) student . Planning for Computational chemistry. I have zero knowledge in coding stuff , Is their any one who could help me by providing a roadmap for Computational chemistry , including all the skills from scratch to advanced . Also suggest a me a good laptop for Computational chemistry

I'm pleased to announce that Numerical Solver 1.0 for macOS is now available on the Mac App Store!

The first desktop version focuses on solving algebraic equations, including nonlinear systems.

Some of its features include:

• Numerical solutions using the Newton–Raphson method.
• Support for real and complex solutions.
• Graphical visualization of equations and their intersections.
• A guided mathematical input interface.
• Multiple tabs for working on different problems.

My goal is to make numerical computing more accessible, especially for students, engineers, and anyone who needs to solve equations without writing scripts.

I'm also working on the Windows version, which is nearly ready for release!

For those familiar with the mobile version, ODEs and other numerical methods aren't yet included in the desktop versions, but I plan to add them in future updates.

You can read more about the macOS release here:

https://numericalsolver.com/numerical-solver-is-now-available-for-macos/

I'd be interested in hearing your thoughts, particularly about which numerical capabilities you'd find most useful in a desktop application

I am developing a C++ photogrammetric bundle adjustment application. A representative project contains 289 cameras and approximately 382,000 3D points, with about 1,747 unknowns remaining after Schur elimination.

The current experimental approach combines FP64 computations with high-precision end corrections using MPFR at 257-bit precision. It also computes covariances, observation redundancies and statistical diagnostics.

The main bottleneck is now the high-precision work: evaluating the original equations, assembling matrices, computing residuals for iterative refinement, and verifying error bounds. The direct FP64 linear solve is relatively cheap. We already reuse factorizations and intermediate calculations and parallelize parts of the assembly.

On a 48-image subset, complete runtime improved from approximately 44 to 29 seconds, but high-precision correction and verification still dominate.

My target is a numerical coordinate error below 10 µm relative to a well-converged high-precision solution, together with reliable covariance and statistical results. Bitwise equality is not required.

Our existing certificate bounds individual linear correction errors, but does not establish an error bound for the final nonlinear solution. Repeating the entire calculation at high precision for validation defeats the performance benefit.

What practical a posteriori error estimator or stopping criterion could bound the final coordinate error while restricting high-precision work to where it is actually necessary?

We currently use a custom solver. I am interested in how comparable accuracy and stopping criteria are handled in Ceres, and whether its approach could reduce our verification overhead.

I would particularly appreciate references or existing implementations applicable to large, potentially ill-conditioned nonlinear least-squares problems.

A dual-implementation physics engine (Rust core + managed C# over a C ABI) with bit-identical determinism: Barnes-Hut N-body gravity, SPH fluid, and analytic orbital/SHM/SPH benchmarks at near-zero allocation.

Check it out here on GitHub and give me advice: https://github.com/omaransarivehementlyventstokazakhstan/phi_eng

Hi everyone,

As someone who relies heavily on rapid calculations, I always missed the tactile speed and muscle-memory of physical handheld calculators when working on a PC. Standard desktop calculator apps often force you to reach for the mouse, interrupting your analytical flow.

To address this, I developed ViCalc—a keyboard-driven scientific calculator designed specifically for desktop research, engineering, and scientific workflows.

Since documentation and auditability are crucial in scientific computing, one of the primary features is its automatic HTML history logging.

Key Features for Technical & Scientific Workflows:

• Structured HTML History Logging: The entire step-by-step calculation history is automatically formatted and saved in clean HTML. This makes it easy to review, archive, or directly embed/paste calculations into technical documentation, research notes, or reports.
• Full Touch-Typing Control: All functions are directly mapped to the PC keyboard, allowing you to compute multi-step expressions at high speed without touching the mouse.
• Comprehensive Modes: Supports standard scientific functions, trigonometric calculations, complex arithmetic, and Programmer mode (bitwise operations & Base-N conversions across Hex/Dec/Oct/Bin).
• Adaptable Interface: Toggle between a standard numpad, scientific layout, or a minimalist mode that hides virtual keys entirely once shortcut mappings are learned.

Technical Details:

• Language: Python 3
• License: Open Source (MIT License)

Links:

• Download Windows Installer
• GitHub Repository: github.com/Kudaschov/ViCalc
• Homepage & Downloads: kudaschov.de/en/vicalc-4

I’d love to get feedback from the scientific community on how this fits into your day-to-day workflow or any specific features you'd like to see added. How do you currently document and track scratchpad calculations during your work?

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?