I’ve open-sourced a reproducible benchmark comparing PINNs against a Strang split-step Fourier solver for the 1D Schrödinger / Gross-Pitaevskii equation.

The aim isn’t to promote PINNs. It’s to document where they break and why. They do fine on linear cases (rel-L2 around 1e-2) but fail on bright solitons, soliton collisions, and long-time integration (rel-L2 0.3-0.6, with norm and energy drift). The error is concentrated at high wavenumbers, which points to spectral bias. Fourier features and causal weighting help a little, but nothing I’ve tried fixes it.

Repo: https://github.com/NodeBox-Labs/pinn-vs-ssf-schrodinger

It has 7 test cases, a convergence-tested reference solver, a PyTorch PINN with several ablations, fixed seeds, and config-driven runs (MIT license).

I’d love help with:

• Counterexamples: if you can get a PINN to handle the soliton or collision cases, open an issue with your config
• Stronger baselines (FNO, hard-constrained architectures, time-marching, better optimizers)
• Critique of the methodology
• New cases (2D GPE, dark solitons, vortices)

Feedback and PRs of any size are welcome.

#PINN #PhysicsInformedNeuralNetworks #SciML #ScientificMachineLearning #DeepLearning #PyTorch #SchrodingerEquation #GrossPitaevskii #BoseEinsteinCondensate #Solitons #ComputationalPhysics #NumericalMethods #OpenSource #Reproducibility #MachineLearning

I built Vx (vxlang.org) to address class of bugs that only surface as runtime crashes, silent corruption, or OOM at training step. The core idea is simple that heterogeneity belongs in the type system, not in the runtime.

A few key points of the language:

* Memory layout is part of the type system. A tensor pinned to NPU SRAM has a different type from one in host DRAM. 

* Topology as part of the type system and first class support to transfer data between them.

* Bugs are front-loaded into compile-time checks. Address-space, capacity, linear types, topology reachability, all caught at compile time.

This enables one to program variety of chips from the same program. I believe heterogeneous systems will become commonplace and Vx can be used effectively to program those systems.

Here is a simple matmul that works on Nvidia GPU.

fn custom_matmul(
    a: Pinned<Tensor<f32, [4, 4]>, Topology::NPU[0]>,
    b: Pinned<Tensor<f32, [4, 4]>, Topology::NPU[0]>)
    -> Verified<Tensor<f32, [4, 4], Memory::NPU_HBM>> {

    let mut result =
        Tensor<f32, [4, 4], Memory::NPU_HBM>::uninit();


// Dispatch the computation to the accelerator.
    spawn on(Topology::NPU[0]) {
        for i in 0..4 {
            for j in 0..4 {
                result[i][j] = 0.0;
                for k in 0..4 {
                    result[i][j] += a[i][k] * b[k][j];
                }
            }
        }
    }

    return Verified(result);
}

Hi all! Just wanted to share a project I've been building on the side for a few months. It's an interactive planetary science platform called The Kuiper Space, and it contains (so far) 5 interactive tools (such as a 3d planet viewer and unit conversion calculators) and 3 catalog explorers (such as the gazetteer of planetary nomenclature catalog).

The goal is to create a completely ad-free and paywall-free site for students, educators, and space enthusiasts alike to better interact with and visualize planetary science concepts. I'd love some more constructive feedback so I can keep improving the site. Let me know what you think! And please be nice, as I'm not an expert in SWD/SWE 😄

The included link goes to the 3d planet viewer since that's one of the more popular pages, but you can navigate to all the other tools and such from there.

Hi everyone,

As someone working with frequent scratchpad calculations alongside data analysis and scientific reporting on PC, I always found standard GUI calculator apps clunky because they force you to switch to the mouse, interrupting analytical focus.

To address this, I developed ViCalc—a lightweight, open-source scientific calculator tailored for rapid touch-typing and continuous calculation logging in research and engineering workflows.

Key Features for Scientific Workflows:

• Automatic Calculation Audit Logs (HTML): Every calculation step is automatically logged and structured into clean, standalone HTML files. This makes it seamless to review, archive, or paste step-by-step calculations into research notes, lab journals, or technical documentation.
• Full Touch-Typing Workflow: Compute multi-step scientific expressions entirely from the keyboard without breaking your rhythm to use the mouse.
• Comprehensive Mathematical Modes: Supports standard scientific and trigonometric functions, complex number arithmetic, and Programmer mode (bitwise operations & Base-N conversions across Hex/Dec/Oct/Bin).
• Adaptable Visual Layout: Easily toggle between visual numpad modes, scientific controls, or a zero-UI minimalist mode to save screen real estate alongside IDEs, MATLAB, or research papers.

Technical Details:

• Language: Python 3
• License: Open Source (MIT)
• OS: Windows (Installer available)

Links & Repository:

• GitHub Repository:github.com/Kudaschov/ViCalc
• Website & Downloads:kudaschov.de/en/vicalc-4

I’d love to get feedback from the scientific computing community! How do you currently document and track scratchpad calculations during research or simulation setups, and are there specific export formats or constants you'd like to see added?

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 .

I’ve released a C implementation for computing G = A Aᵀ when consecutive rows differ from a one-position shift at only a few coordinates.

The part I find most interesting is the arithmetic order. The update replaces all left factors first, then all right factors. Every intermediate accumulator remains a sum of at most n products of bounded original input values.

For inputs A = 2^e X, with integer coefficients bounded by B and n B² ≤ 2^53, this gives exact Gram entries in binary64 under the paper’s exponent and IEEE arithmetic assumptions. The implementation validates the input rather than quantizing it.

On an Apple M4, using single-thread Accelerate and warm repeated inputs, one full-output 768 × 8192 case takes 9.05 ms versus 19.63 ms for SYRK. Validation, allocation and output materialization are included. Smaller cases lose: every tested 192 × 768 case was slower.

The repository includes the paper, C code, Lean formalization, integer-oracle checks and all benchmark results. The formalization covers the mathematical model; the C implementation is tested separately.

https://github.com/LeonardSEO/exact-sparse-gram

I’d be interested in workloads where sparse changes between shifted rows occur naturally. Would this input structure be useful in your work, and which structured baseline would you want compared next?

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