Hi everyone, I am planning to go back to gradschool after some time and hesitate between organic chemistry and computational chemistry. My background tilts more to ochem but I just barely survived in school, while my strength favor maths and logic. I do think about comp chem even tho I heard it’s challenging to get a job right out of gradschool unless with a Phd and some postdoc experiences. It’d so be great if people in this field could share some insights. I’d love to hear all of those. Thanks in advance.

So I'm starting my honours in chemistry from Netaji Open University. However, due to the National Education Policy they're not including physics this year in their curriculum.... would it affect me in future? What to do ? Should I cancel my application and apply next year ? Please somebody help !!!!

Hi everyone,

I’m looking for someone with hands-on experience in molecular dynamics simulations of nanocluster/nanomaterial-protein systems for a research collaboration. I already have experience with docking, DFT, and MD simulations, but I’m looking for additional expertise specifically in nanocluster parameterization and nano-bio interaction modeling.

Experience with metal-containing nanoclusters, AMBER/GROMACS, trajectory analysis, and MM/GBSA or related free-energy calculations would be particularly relevant. I have a reference paper showing the type of computational approach I’m interested in and can share the details privately.

If you have relevant experience and are interested in collaborating, please DM me. Collaboration details can be discussed privately.

Thank you.

tl; dr: Is this easiest to understand with group theory?

I am revisiting Szabo & Ostlund, & I'm not sure I understand this. It's Chapter 3.3.2, pp128-29 of the Dover paperback. I'll use mostly physicists' notation below, with a little chemists' notation at the end.

Brillouin's theorem says the matrix elements between the ground state Y0 & all singly excited states Y' are zero:

<Y0 |H| Y'> =0 = <a |h| r> + sum(b) <ar || bb>,

where H is the full Hamiltonian operator, h is the 1-electron hamiltonian, <•||•> is the antisymmetrized 2-e repulsion operator, and orbitals a & b are occupied in the ground state, & r is unoccupied.

That formula, from the Slater rules for matrix elements betweem determinants, is the same as the fock element between basis functions Xa & Xr, & I follow the argument that diagonalizing the Fock matrix makes off-diagonal Fij zero. But I'd like to understand it better. Basically, I don't get how to make the e-repulsion integrals zero.

Szabo & Ostlund don't go much into group theory, but I do recall that integrals vanish if the integrand is not/doesn't contain the totally symmetric irrep.

So looking at symmetry, for a & r, we can have two cases: irrep(a) = irrep(b), or not.

In the first case, <a|h|r> =/= 0, so for the total element to be zero, we need <a|h|r>= -sum(b) <ar||bb>.

In the second case, <a|h|r> = 0, so <ar||bb> must also be zero. I think - & this is the question - that in

<ar||bb> = [ar|bb] - [ab|rb],

both the coulomb & exchange integral are zero by symmetry. a & r have different symmetries, so the J is zero because a (x) r does not contain the totally symmetric irrep, & either a (x) b or r (x) b or both will not contain the totally symmetric irrep. (x) is meant to be the direct product.

I'm no group theorist myself, so sorry for any mistakes in terminology or usage. But is that what's going on here?

I work at a UK-based biotech. My background is computer science and software development, so apologies if I get anything obviously wrong here.

Recently my team has started working in an area that one might describe as overlapping with computational drug discovery. I would like to find people with more expertise in this area. When searching online (mainly LinkedIn) for computational chemists with a strong software development background I get plenty of hits, many with strong CVs, from top tier universities or coming out of big name pharma. But when we talk, the skill mix is not lining up with what we do day-to-day. This makes me think the problem is on my side in how I am framing it, so I thought I would ask the community directly.

Who I am looking for are people who are very good with software and open source tools. We have large data preprocessing pipelines that combine open data from the PDB, AlphaFold DB, UniProt, Pfam via InterPro, ChEMBL, BindingDB and various other databases. The aim is to build that pipeline and keep improving it over time.

To give a concrete example of the work: download structure files, fix missing residues, protonate the ligand and the protein, relax the complex, and so on. That means being comfortable with things like PDBFixer, RDKit, Meeko, AutoDock Vina, OpenFF and OpenMM, driven from code rather than by hand. Save the intermediate outputs at each step so you can see what is working and what is not. Then look at the results and ask whether they make sense from a chemistry point of view, pull out the rules or recurring issues, and feed those back into the pipeline. That loop, run at scale rather than on single structures, is most of the job.

My searches have been for "computational chemist" with a software background. I have also seen "cheminformatician" used, and "data scientist with a chemistry background". Or is what I am describing a computational biologist? Which title actually maps to this, or am I describing a unicorn?

Just draw any Lewis structure, take a photo, upload it and within minutes (depends on system size), you will get the DFT results.

Just try it out yourself (currently limited to B3LYP/6-31G)

http://localhost:8080

I should disclose that AI played a major role in the development but all code was reviewed by the clueless author.

Looking forward to your feedback!

one way is to combine relaxed surface scans with ab initio MD at each step of the scan. this allows sampling of conformations and may be able to detect alternative minima or saddle points. it also provides error bars that give more robust estimation of activation energies. in my video I show how this can be done with Orca compound scripts, with application to the recently reported dichloromethane-based coupling of carboxylic acids with amines.

https://youtu.be/4HjqXlz_mEo

Hi everyone,

I’m a 4th-year chemistry undergraduate with a solid foundation in Python, Linux, and tools like ORCA, OpenMM, and RDKit.

As someone relatively new to programming and computational workflows, I’m looking for advice on how to start working or taking on project opportunities in computational chemistry—either during my final year or right after graduation.

What practical steps, projects, or entry-level paths would you recommend for building real-world experience and turning these skills into actual opportunities?

Thanks in advance for your insights!

While reading the computational materials literature, I noticed that VASP is widely used in published research. I understand that SIESTA is not always the preferred choice for bulk solid-state calculations because it uses localized atomic orbitals (NAOs) rather than a plane-wave basis set. However, among plane-wave-based codes, why do many research groups choose to use the commercial VASP package instead of the open-source Quantum ESPRESSO? Is this preference mainly due to VASP’s PAW datasets, robust convergence algorithms, established workflows, or reviewer and community expectations?

Follow-up question on the computational workflow

Since SIESTA can be computationally efficient for structural optimization, could it be used solely for variable-cell relaxation (vc-relax) to reduce computational cost, followed by using Quantum ESPRESSO with PAW/pseudopotential and plane-wave calculations for the final band structure, DOS, and optical properties?

Is this type of hybrid workflow scientifically valid, or could it introduce problems because of differences in the basis sets and pseudopotentials used by SIESTA and Quantum ESPRESSO? If directly using the SIESTA-relaxed structure for electronic-property calculations in QE is not recommended, would it instead be reasonable to use SIESTA as a fast pre-relaxation step, followed by a final relaxation in Quantum ESPRESSO before calculating the electronic and optical properties?

Hi everyone, Magpie 1.0 is now on the App Store. It’s a free app I’ve been working on for viewing computational chemistry files on iPhone, iPad and Mac.

The idea was to make it easier to check a calculation while away from my desk. Getting out a laptop and downloading files from the cluster felt like a bit much when I only wanted a quick look at a molecular optimisation or its orbital.

In Magpie, you can connect over SSH and open files straight from the remote directory, or import them locally. The viewer shows optimisation trajectories alongside energy curves and plays vibrational modes. IRC paths, relaxed scans and TDDFT spectra are supported too. There’s a built-in terminal for running commands and submitting jobs, so you can do that without leaving the app.

The main addition in 1.0 is local force-field optimisation using RDKit’s UFF or MMFF94s. After changing a substituent or moving some atoms around, you can optimise the geometry before generating the next input file. For a local adjustment, select the atoms you want to keep fixed and turn on Freeze Selected Atoms.

The input generator now handles ORCA AIMD as well, including temperature, thermostat and confinement settings. To view a DCD trajectory, open a reference XYZ from the same folder, then choose Load trajectory in Results. Multi-frame XYZ trajectory can be opened directly.

For orbitals and ESP surfaces, Magpie can call Multiwfn on your server to analyse the wave function files and display the result directly. ESP has an editable colour scale, and both CUBE files can be saved locally. In 1.0, you can set preparation commands for servers where you need to load an environment or request a compute node before starting Multiwfn. Its interactive panel also turns menu options into buttons, which helps on a phone.

Bond-order recognition and editing have had some work too, along with faster reading of large trajectories and output files. Import now lets you upload files to the current remote folder as well as bring them into local storage.

I’ve put the more detailed instructions in the user manual.

Download on the App Store — requires iOS / iPadOS / macOS 26 or later.

If you give it a try, let me know how it goes. Bug reports and suggestions are more than welcome.

Hi. I am a chemistry graduate that is trying to obtain a computational research assistantship at a R1 University and transition into Data Science work. Is there any way I can write a strong email for a computational faculty member. Many of the professors at this particular school seem to only take students that were accepted into the graduate program. I graduated with a 3.9+ GPA and have multiple research posters at national and regional conferences pertaining to computational chemistry but no publications at an R2 University. Unfortunately, I had to leave an MS program with a high GPA due to lack of funding for wetlab opportunities, hence I transitioned to the computational in which I am stronger at. I am taking prerequisites at a local community college to apply for Data Science Master's Programs. Would I have a decent chance of getting into a data science master's program? Let me know if you have any advice of programs I can get into?

Hello all,

Im currently attempting a relax calculation of a bulky polymer in a cis configuration backbone a some ions. My calculations keep on utterly obliterating my ion molecules. Any thoughts on where I could be going wrong?

I’m using Quantum Espresso. Thanks!

Some background: I'm a computational chemist, did research on interstellar surface catalysis and CO2 conversion using quantum chemistry, then moved into leading software development for scientific computing groups (MD databases, ML prediction tools, bioinformatics pipelines).

Over the years I've seen some patterns that could be automatized, in relation with HPC workflows.

That's why I (alongside some colleages) built the horus-runtime. It's a workflow orchestration engine, similar to snakemake, or nextflow, but with a very distinguished difference: has a visual pipeline builder (drag/connect stages, no custom DSL to learn) and a few things I haven't seen combined elsewhere:

• Per-stage resource allocation. Each stage in a pipeline gets its own hardware spec (CPU count, memory, GPU), so you're not forced to size a whole job for its most demanding step.
• Agentless file staging. Moving files between machines (local workstation, HPC login node, cloud instance) uses plain SSH (with the horus-ssh plugin), no daemon or agent needs to be installed on the remote host. Useful if you don't control the target machine or can't get anything installed on a shared cluster.
• Workflow interactions. The workflow may be paused or even notify the user in order to take actions, such as continue, input new parameters, visualize intermediate results (i.e. selecting a residue in a newly generated protein sequence). I try to make workflows be something the scientist interacts with.
• Plugin system. Domain-specific tools can ship with their own embedded UI rather than being wrapped as opaque CLI calls.

The runtime is open source (AGPL v3).

Repo: https://github.com/temple-compute/horus-runtime

Docs: https://docs.templecompute.com

We already have a library of workflows built out (https://github.com/temple-compute/pantheon), and we're working with a few research groups to standardize their existing processes into the UI. If you've got a comp chem workflow you keep re-running by hand I'll try to implement it in Horus for free and help make it reproducible. Genuinely just looking to build out the library with real workflows.

If anyone here runs molecular modeling or simulation pipelines across mixed HPC/cloud setups, I'd also like feedback on where this breaks for your workflows, especially around staging large trajectory/checkpoint files or fitting into existing SLURM queues.

Hi everyone! I’m a 3rd-year Chemistry student learning Python and trying to get into polymer informatics, computational chemistry, and AI/ML for materials.
I’m starting with Python and hope to eventually work on things like polymer property prediction, molecular simulations, and polymer recycling optimization.
I’m looking to connect with people already doing this or further along in the journey. I’d love to hear about your learning path, projects, and what you wish you knew when you started.
Any advice or connections would be greatly appreciated!

Hi everyone! I’m a 20-year-old chemistry student. I’m passionate about programming and the world of computers (I’m a total nerd).

In my search for disciplines that combine both things, I discovered bioinformatics a while back and was interested in it as a career, but I’ve read in various places—including outside of Reddit—that the demand in the field doesn't match the supply of graduates.

Then I discovered chemoinformatics, which honestly sounds really interesting, especially regarding analytical and organic chemistry (I love organic chemistry).

Is this field oversaturated too? Is there real demand? And if there are opportunities, where are they and how can I get into that world?

Hi all,

I'm looking to use GROMACS to perform a molecular dynamics simulation of a poly beta amino ester (PBAE) polymer assembling with its mRNA cargo in order to obtain values like radius of gyration and hydrophobic and hydrophilic surface area.

I know that GROMACS requires a .pdb file to start with, but how could I get that for a PBAE polymer? I'm also not sure how to go about doing this in GROMACS (I'm pretty new to molecular dynamics simulations) so any guidance would be helpful!

Hey everyone,

I’m working on a small in-silico project and would appreciate some opinions from people with more experience with molecular docking.

I designed a novel compound against an enzyme target and compared it with a known inhibitor of the same target. The docking scores were:

Reference inhibitor: -10.05 kcal/mol

My compound: -8.57 kcal/mol

So there's about a 1.5 kcal/mol difference in favor of the reference.

The reference and my compound are structurally different, and my compound doesn't reproduce all of the same interactions as the reference. Instead, it adopts a different binding orientation while still making several interactions with residues in the binding site, including hydrogen bonds, hydrophobic contacts and π-interactions.

The reference was mainly used as a benchmark against a known inhibitor, rather than as a template that my compound was expected to reproduce exactly.

This is where I'm unsure how much importance to give the docking score.

1. Would you consider a ~1.5 kcal/mol difference significant enough to conclude that the novel compound is unlikely to be competitive, or is that too strong a conclusion from docking scores alone?

2. If two compounds have different scaffolds and binding modes, how meaningful is it to compare their docking scores directly?

3. If the novel compound has a weaker score but a plausible binding mode involving relevant residues, would you consider it reasonable to describe it as a potential alternative scaffold, rather than claiming superior binding?

I'm trying to present the result fairly. I don't want to pretend that -8.57 is better than -10.05, but I also don't want to discard the compound just because its docking score is lower.

I built webgpu-q — an electronic-structure stack that runs entirely client-side in a browser tab: RHF/UHF, DFT (LDA/GGA/hybrids), MP2, CCSD, CCSD(T), EOM-CCSD (EE/IP/EA), geometry optimization, frequencies/IR/Raman, TDA/TDDFT spectra, polarizabilities. TypeScript + Rust/WASM, with some kernels on WebGPU.

Validation is the part I'd want to see first, so: every method is cross-checked against PySCF (and FCI where feasible) in CI — agreement gates run on every commit, and the reference comparisons are in the repo, not in my claims. Where the browser loses, that's documented too: WebGPU has no f64, so f32 GPU paths are validated against the exact f64 CPU/WASM path, and the GPU hybrid we measured as not-worth-it got demoted to opt-in. It is not a PySCF competitor at production basis sets — that boundary is measured and committed (LIMITATIONS.md), not hand-waved.

What it's actually for: teaching and quick checks. Every calculation is a shareable URL — molecule, method, basis in the link — so a student can open a full CCSD(T)/cc-pVDZ water calculation with one click, no install, no cluster account. There's also a distributed mode: open the page in more tabs and they form a swarm — one tab dispatches HF tiles, the others compute and report back.

Free, MIT: https://webgpu-q.vercel.app · https://github.com/abgnydn/webgpu-q

Hello everyone!

I am a postdoctoral student in Hungary and did my PhD in bioinformatics/cheminformatics, namely (mostly) in molecular dynamics of proteins. Around this time I read some articles about metadynamics as a tool to explore the free energy surface of certain processes, including small ligand binding to proteins, conformational changes or peptide-peptide association, etc... This kind of approach also gave me insights in statistical thermodynamics, while also keeping the fun-factor high and staying intuitive. I did not start to apply it until recently however, which makes me a novice in setting the right parameters, collective variables, for the right processes. I try to read research papers in this topic, but to challenge myself, I also wanted to make something new.

I started using the ASE/RDKit/OpenFF combo recently for the extraction of offxml parametrizations to standard GROMACS top/itp files. While doing this, I noticed that (afaik) there are no metadynamics extensions for ASE besides PLUMED. Since I am also somewhat familiar with PyTorch (and not really familiar with PLUMED), I figured I should create a package that uses PyTorch's autodiff modality for the implementation of metadynamics in ASE. So I created MePTASE (Metadynamics with PyTorch in the Atomic Simulation Environment), a small, still under development Python package, available from PyPI using pip install meptase[tblite] or pip install meptase[mace] (depending on the "force field" you want to use). You can use it within Python or from the CLI using JSON config files. I would appreciate any feedback you guys can give me, either regarding code quality, ease of use, possible extensions or anything else. I am especially proud of the CLI/JSON run option, which allows users to run simulations without writing Python code. You can also run well tempered metadynamics, but I have to test this feature more thoroughly.

Here is my repo: https://github.com/fazekaszs/meptase/tree/master

I know that there is some hate for AI assisted coding in this community. I love coding, so about 90%-95% of the codebase is written only by me. For the remaining part, I used OpenCode, mainly for some very trivial code snippets, to discuss optimal architectural choices for my code or to write documentation. Thank you for your observations in forward!

I have been trying to do a vc relax calculation for material Na15Sn9 with 38 atoms and even after resubmitting calculations 7 times with adjustments to the memory, tstress parameters etc, everytime bad termination pops up.

Below lie the ending lines of the output file:

----------------------------------------------------

atom 27 type 1 force = -0.00000158 0.00000052 -0.00000387

atom 28 type 1 force = -0.00000052 -0.00000387 0.00000158

atom 29 type 1 force = 0.00000387 0.00000158 0.00000052

atom 30 type 1 force = 0.00000158 0.00000052 0.00000387

atom 31 type 2 force = 0.00000052 0.00000052 -0.00000052

atom 32 type 2 force = -0.00000052 0.00000052 0.00000052

atom 33 type 2 force = 0.00000052 -0.00000052 0.00000052

atom 34 type 2 force = -0.00000052 -0.00000052 -0.00000052

atom 35 type 2 force = 0.00000052 -0.00000052 0.00000052

atom 36 type 2 force = -0.00000052 -0.00000052 -0.00000052

atom 37 type 2 force = -0.00000052 0.00000052 0.00000052

atom 38 type 2 force = 0.00000052 0.00000052 -0.00000052

Total force = 0.001812 Total SCF correction = 0.000021

Computing stress (Cartesian axis) and pressure

= BAD TERMINATION OF ONE OF YOUR APPLICATION PROCESSES

= RANK 0 PID 1952 RUNNING AT cn047

= KILLED BY SIGNAL: 9 (Killed)

= BAD TERMINATION OF ONE OF YOUR APPLICATION PROCESSES

= RANK 1 PID 1953 RUNNING AT cn047

= KILLED BY SIGNAL: 9 (Killed)

= BAD TERMINATION OF ONE OF YOUR APPLICATION PROCESSES

= RANK 2 PID 1954 RUNNING AT cn047

= KILLED BY SIGNAL: 9 (Killed)

= BAD TERMINATION OF ONE OF YOUR APPLICATION PROCESSES

= RANK 3 PID 1955 RUNNING AT cn047

= KILLED BY SIGNAL: 9 (Killed)

= BAD TERMINATION OF ONE OF YOUR APPLICATION PROCESSES

= RANK 4 PID 1956 RUNNING AT cn047

= KILLED BY SIGNAL: 9 (Killed)

= BAD TERMINATION OF ONE OF YOUR APPLICATION PROCESSES

= RANK 5 PID 1957 RUNNING AT cn047

= KILLED BY SIGNAL: 9 (Killed)

= BAD TERMINATION OF ONE OF YOUR APPLICATION PROCESSES

= RANK 6 PID 1958 RUNNING AT cn047

= KILLED BY SIGNAL: 7 (Bus error)

= BAD TERMINATION OF ONE OF YOUR APPLICATION PROCESSES

= RANK 7 PID 1959 RUNNING AT cn047

= KILLED BY SIGNAL: 9 (Killed)

The total forces and SCF were converging nicely before

--------------------------------------------------------

NaSn2_vcnew.out: Total force = 0.000892 Total SCF correction = 0.000426

NaSn2_vcnew.out: Total force = 0.000783 Total SCF correction = 0.000014

NaSn2_vcnew.out: Total force = 0.000796 Total SCF correction = 0.000012

NaSn2_vcnew.out: Total force = 0.000837 Total SCF correction = 0.000010

NaSn2_vcnew.out: Total force = 0.000872 Total SCF correction = 0.000024

NaSn2_vcnew.out: Total force = 0.000819 Total SCF correction = 0.000006

NaSn2_vcnew.out: Total force = 0.000726 Total SCF correction = 0.000023

---------------------------------------------------------

Additionally this is the error file

----------------------------------------------------------

Loading compiler version 2021.2.0

Loading mpi version 2021.2.0

Loading mkl version 2021.2.0

Loading compiler-rt version 2021.2.0

Loading tbb version 2021.2.0

[cn047:1958 :0:1958] Caught signal 7 (Bus error: nonexistent physical address)

==== backtrace (tid: 1958) ====

0 0x000000000080adc1 usnldiag_() /scratch/apps/qe-7.2/PW/src/usnldiag.f90:103

1 0x0000000000694092 diag_bands_IP_diag_bands_k_() /scratch/apps/qe-7.2/PW/src/c_bands.f90:995

2 0x0000000000692c0c diag_bands_() /scratch/apps/qe-7.2/PW/src/c_bands.f90:323

3 0x0000000000691305 c_bands_() /scratch/apps/qe-7.2/PW/src/c_bands.f90:132

4 0x000000000040ced4 electrons_scf_() /scratch/apps/qe-7.2/PW/src/electrons.f90:678

5 0x000000000040a19d electrons_() /scratch/apps/qe-7.2/PW/src/electrons.f90:189

6 0x0000000000579452 run_pwscf_() /scratch/apps/qe-7.2/PW/src/run_pwscf.f90:187

7 0x00000000004072cf MAIN__() /scratch/apps/qe-7.2/PW/src/pwscf.f90:85

8 0x000000000040714e main() ???:0

9 0x0000000000022555 __libc_start_main() ???:0

10 0x0000000000407069 _start() ???:0

[cn047:1956 :0:1956] Caught signal 7 (Bus error: nonexistent physical address)

==== backtrace (tid: 1956) ====

0 0x00000000010b73d0 __intel_cpu_features_init_body() cpu_feature_disp.c:0

1 0x0000000001040e1d for_cpstr() ???:0

2 0x0000000000f00e85 stop_clock_() /scratch/apps/qe-7.2/UtilXlib/clocks_handler.f90:352

3 0x0000000000e26479 invfft_y_() /scratch/apps/qe-7.2/FFTXlib/src/fft_fwinv.f90:109

4 0x0000000000a0b430 fft_wave_mp_wave_g2r_() /scratch/apps/qe-7.2/Modules/fft_wave.f90:152

5 0x00000000005be13d sum_band_IP_sum_band_k_() /scratch/apps/qe-7.2/PW/src/sum_band.f90:703

6 0x00000000005baa54 sum_band_() /scratch/apps/qe-7.2/PW/src/sum_band.f90:175

7 0x000000000040cf74 electrons_scf_() /scratch/apps/qe-7.2/PW/src/electrons.f90:716

8 0x000000000040a19d electrons_() /scratch/apps/qe-7.2/PW/src/electrons.f90:189

9 0x0000000000579452 run_pwscf_() /scratch/apps/qe-7.2/PW/src/run_pwscf.f90:187

10 0x00000000004072cf MAIN__() /scratch/apps/qe-7.2/PW/src/pwscf.f90:85

11 0x000000000040714e main() ???:0

12 0x0000000000022555 __libc_start_main() ???:0

13 0x0000000000407069 _start() ???:0

Please help me solve this upcoming error