Among free software packages, which one has robust CASSCF functionality? The FCI solver can be implemented in either way, e.g., direct solver, DMRG, etc.

  • 6
    $\begingroup$ How do you define "free"? As in free coffee or free speech or both? If we are talking about latter, then ORCA may not the choice because it is not open source. $\endgroup$
    – Y. Zhai
    Commented May 7, 2020 at 7:59
  • 2
    $\begingroup$ GAMESS can do some pretty decent MCSCF (example input). I don't have time to answer properly, so if anyone wants to extend on that, be my guest. $\endgroup$ Commented May 7, 2020 at 10:07

9 Answers 9



I'm surprised that the other two answers were given without yet any mention of OpenMOLCAS yet!
There is a recent paper[1] about it for which I happen to be one of the many co-authors.

MOLCAS has the quality of a commercial software like MOLPRO, since it was a commercial software that people paid big money for since the 1980s, but recently an open source branch called OpenMOLCAS was made freely available.

Furthermore, (Open)MOLCAS is the only program with CAS in its name, suggesting that it caters well to CASSCF calculations. Indeed, it originated in the 1980s in the group of Björn Roos, and Roos in fact described the CASSCF method in the year 1980 and later in the same decade developed the CASPT2 method.

CASSCF, RASSCF, and GASSCF are all implemented well in OpenMOLCAS, as it is used mainly by people who specialize in active-space calculations.


  1. J. Chem. Theory Comput. 2019, 15 (11), 5925–5964
  • 6
    $\begingroup$ A developer of openmolcas told me that they can use Docker containers. So this might be an easy solution to get started on your own cluster. $\endgroup$
    – Cody Aldaz
    Commented May 5, 2020 at 23:08
  • 1
    $\begingroup$ It seems like you need the magic CLI command (thanks to S.V.): \$ docker run -v $PWD:/home/ steabert/openmolcas /home/molcas.input $\endgroup$ Commented Jun 11, 2020 at 19:45
  • $\begingroup$ @AlessioValentini Welcome to the site! We are only 1 month old, so this is the best time to join us! I should have actually advertised on the MOLCAS facebook group earlier. $\endgroup$ Commented Jun 11, 2020 at 19:48
  • $\begingroup$ There is also AutoCAS as a tool for OpenMOLCAS that help with the selection of the active space. $\endgroup$
    – Kexanone
    Commented Mar 13, 2021 at 18:58
  • $\begingroup$ doi.org/10.1063/5.0004835 here's a newer reference $\endgroup$ Commented Jun 4, 2021 at 0:26


ORCA (forum). It is fully featured, efficient, and free for academics. The input is straightforward:

# CASSCF(2,4) example from the manual,
# section, page 108


  nel 2
  norb 4

* xyz 0 1
Be 0 0 0

Some resources for CASSCF:



Personally I would use pyscf, its not the most efficient or user friendly but it's free.

  • 1
    $\begingroup$ The active space solver in PySCF can also be easily customized: instead of string-based CI, one can use DMRG, coupled-cluster, etc. $\endgroup$ Commented May 17, 2020 at 18:07
  • 3
    $\begingroup$ PySCF is surprisingly efficient in my experience... Depends what you're comparing to, I guess. One of the main aspects is it supports general contractions, so it's blazing fast for heavier elements compared to codes that don't... $\endgroup$ Commented May 17, 2020 at 18:08


NWChem is a commonly use quantum chemistry software package with CASSCF included.

NWChem is free, as in both free coffee and free speech. It is under ECL-2.0.

It is written in FORTRAN (in case you want to do some development).



The code is available through GitHub[1] and has been described in WIRES.[2]

The main advantages of BAGEL is that it has better memory and parallelization than MOLPRO. For example, MOLPRO (not Free) is restricted to 32 active orbitals. While not a problem for CASSCF, this will severely affect your ability to do CASPT2 calculations. (they have fixed this problem in 2012 and it requires the use of rs2c keyword)

BAGEL also has the added advantage of being able to calculate CASPT2 non-adiabatic couplings.

I should warn, however, that the developers specifically say

BAGEL is intended for use in parallel environments with a large amount
of distributed memory (e.g., hence there is no disk interface). We are NOT going to optimize BAGEL for a stand-alone workstation.

This is good news if you are working on a cluster since that means your calculation will run faster, but is bad news if you're working on a smaller scale.


  1. Project on GitHub: https://github.com/nubakery/bagel
  2. Shiozaki, T. BAGEL: Brilliantly Advanced General Electronic‐structure Library. WIREs Comput. Mol. Sci. 2018, 8 (1). DOI: 10.1002/wcms.1331.
  • $\begingroup$ +1. I wonder though, what is meant by "While not a problem for CASSCF, this will severely affect your ability to do CASPT2 calculations" ? What is severely affected in MOLPRO here? It is certainly possible to include hundreds of orbitals in a MOLPRO caspt2 calculation as long as the active space has no more than 32 orbitals. Also, I wonder if you could elaborate a bit on how BAGEL is better for memory and parallelization? Does BAGEL really require less RAM, or is it just the fact that it's been tested for a larger number of distributed nodes than MOLPRO has? $\endgroup$ Commented May 9, 2020 at 22:33
  • $\begingroup$ Finally, I didn't know about BAGEL's ability for non-adiabatic couplings: for this, what exactly is it that BAGEL can do? $\endgroup$ Commented May 9, 2020 at 22:33
  • $\begingroup$ a 32 orbital active space is too computationally demanding in general, so it's never an issue. However, when doing the correlated CASPT2 calculation MOLPRO considers closed orbitals "active" as a perturbation not just the "active space". So it crashes if there is more than 32 "active" orbitals. It's quite confusing. I'm 99% sure this is not a problem in BAGEL because it's not written using the same outdated coding/memory practices. $\endgroup$
    – Cody Aldaz
    Commented May 9, 2020 at 23:08
  • $\begingroup$ There is no limit on the number of closed orbitals in the rs2c and mrcic programs in MOLPRO 2012 and later (see the answer by Shamasundar here: molpro.net/pipermail/molpro-user/2017-June/006959.html). I wouldn't say that this is due to outdated coding/memory practices not used in BAGEL though. In my experience, MOLPRO is about as efficient as it can get for most routines including integrals, HF, coupled cluster, and CASSCF/CASPT2. That thread I sent you says a bit about why they chose to use 32 as the cut-off for the older routines: it just seems to be a choice they felt was right. $\endgroup$ Commented May 9, 2020 at 23:30
  • $\begingroup$ I see, one needs to use the RS2C and MRCIC, keywords $\endgroup$
    – Cody Aldaz
    Commented May 14, 2020 at 15:25


Columbus is an alternative package for CASSCF and other multireference methods. There is a free and open-source distribution. It is a bit old fashioned but still widely used.

Newest Reference

H. Lischka, R. Shepard, T. Müller, P. G. Szalay, R. M. Pitzer, A. J. A. Aquino, M. M. A. do Nascimento, M. Barbatti, L. T. Belcher, J.-P. Blaudeau, et al., J. Chem. Phys. 2020, 152, 134110. DOI: 10.1063/1.5144267

  • $\begingroup$ Doesn't look like open-source, "COLUMBUS can be obtained free of charge. Fill out the COLUMBUS registration form (pdf, html) and send a signed and scanned copy to Felix Plasser." $\endgroup$ Commented Jun 4, 2021 at 0:28
  • $\begingroup$ I guess it depends on the definition of "open-source". Anyone wishing to view the COLUMBUS source can do so by filling out a short registration form. I don't know if that complies with the most stringent definition of open-source. But for practical purposes, anyone wishing to can view the source. $\endgroup$
    – Felix
    Commented Jun 7, 2021 at 9:31
  • $\begingroup$ There is much more to open source than being able to view the source. You can also get the sources to the program that shall not be named by signing a license agreement and paying the license fee, but that does not make it open source. See opensource.org/osd for the generally accepted definition of open source. $\endgroup$ Commented Jun 7, 2021 at 15:15


GAMESS (https://www.msg.chem.iastate.edu/GAMESS/) has an MCSCF module, which can perform CASSCF. For generating configurations it can use determinants, or configuration state functions (CSFs). There are first order, quasi-second order, full newton-raphson and other convergers for the iterations. GAMESS can also perform full second order CI.

GAMESS documentation has a section on how to do MCSCF calculations.

GAMESS is free to obtain, and you can also access its source code, but strictly speaking, it is not open-source because its license is proprietary.



Psi4 (https://psicode.org/) is another open-source alternative (LGPL).

I haven't used it myself but it supports CASSCF.

  • $\begingroup$ The link seems to suggest that they plan to allow for CASSCF, but it is not finished yet: "...CASSCF (=4) a complete-active space SCF calculations (currently not implemented)" $\endgroup$
    – Tyberius
    Commented May 28, 2021 at 15:52
  • $\begingroup$ Oops, thanks for pointing this out! I think this was just a badly chosen link on my side (perhaps outdated docs?). I've updated it now, the new link includes a sample input. $\endgroup$ Commented May 28, 2021 at 16:29
  • $\begingroup$ It looked like the previous link was specifically about the PSI4 interface to CFOUR, so it may just be that this interface hasn't been update, but CASSCF is available natively. $\endgroup$
    – Tyberius
    Commented May 28, 2021 at 16:51


For what I know also the Dalton suite is able to run CASSCF. It's also an open source software. You can find the tutorial to run CASSCF calculation here.


You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .