Psi4: an ab initio quantum chemistry package with a Python driver
Open-Source Quantum Chemistry – an electronic structure package in C++ driven by Python
At a glance
- What is it?
- Psi4 is an LGPL-3.0 licensed suite of ab initio quantum chemistry programs whose demanding parts are written in C++, exported to Python with Pybind11 and driven from a flexible Python layer. It routinely runs computations with more than 2500 basis functions and ships as a conda package across Linux, macOS, Windows and WSL.
- Who is it for?
- Psi4 is a good pick for a computational chemistry group that wants an ab initio electronic structure code they can script, either through the Psithon input language or through the PsiAPI Python interface, because the same C++ core serves both and the conda distribution removes the build entirely; it is the wrong pick if you need a turnkey package for a specific study, since the input file is a program you write rather than a molecule you pick from a menu, and before you build it yourself you should check the Python version range, since the supported versions run from 3.10 to 3.14 and the manual page linked from the README is built nightly from master rather than from a release.
- Can I use it commercially?
- Yes, with conditions. LGPL-3.0 is a weak copyleft licence: you can use it inside commercial and closed-source software, but if you distribute changes to its own files, you must publish those changes under the same licence.
- Is it still maintained?
- Yes. The repository received new commits within the last day.
- What is it written in?
- Mainly C++, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on October 23, 2026, and from our analysis. They are not legal advice.
Editorial analysis
C++ for the physics, Python for the user
Psi4 is an open-source suite of ab initio quantum chemistry programs designed for efficient, high-accuracy simulations of molecular properties. The architecture is stated in two sentences and it explains everything about how the project feels to use.
With computationally demanding portions written in C++, exports of many C++ classes into Python via Pybind11, and a flexible Python driver, Psi4 strives to be friendly to both users and developers.
So the split is deliberate. The integral evaluation, the SCF iteration, the basis set machinery and the post-processing kernels are C++ because that is where the performance lives. Those classes are exposed to Python through Pybind11, and the layer you actually interact with is Python.
The scale claim gives a sense of the target: they routinely perform computations with more than 2500 basis functions on multi-core machines. That is well beyond what a Python-only implementation would attempt, and it is the reason the C++ core exists at all.
The primary language is listed as C++ and the licence is LGPL-3.0, with the copyright held by the Psi4 Developers, 2007 to 2026, and a note that the copyrights for code used from other parties are included in the corresponding files.
Two ways to drive it, Psithon and PsiAPI
The tutorial section points at two separate entry points, and choosing between them is the first decision a new user makes.
For Psithon, the input is a program in a Python-like syntax that is run with psi4 job.in. The tutorial for that path is at the psicode manual. For PsiAPI, the input is a normal Python script that imports psi4 and calls the API directly, run with python job.py, and the documentation for it is the psiapi page.
The difference matters more than the syntax suggests. Psithon is a domain-specific language that gives you the full computational vocabulary of the package in a script, and it is what the sample inputs in the repository use. PsiAPI is a Python library, which means you can write ordinary Python around it, put it in a notebook, or drive it from your own program.
The repository makes the scale of the PsiAPI surface visible. The samples/ directory contains a long list of individual computation directories, and the names read like a table of contents of quantum chemistry methods: aediis, ao-casscf-sp, ao-dfcasscf-sp, basis-ecp, brianqc, casscf-fzc-sp, casscf-sa-sp, casscf-semi, casscf-sp, castup, cbs-delta-energy, cbs-parser, cbs-xtpl-alpha, cbs-xtpl-dict, cbs-xtpl-energy-conv, cbs-xtpl-energy, cbs-xtpl-freq, cbs-xtpl-func, cbs-xtpl-gradient, cbs-xtpl-nbody, cbs-xtpl-opt and cbs-xtpl-wrapper.
So the samples are not toy demonstrations. Each one is a complete worked example of a particular method or property, and the set spans coupled cluster, configuration interaction, perturbative theory and composite methods. A new user picks the directory closest to the calculation they want and edits it, which is a far more practical starting point than a reference manual.
Conda first, source build second
The installation story in this project is unusual in a good way: the primary route is a binary package, and building from source is the alternative.
The Anaconda badges point at both the psi4 channel and conda-forge, with the conda-forge package being the one linked for the latest release. The instructions are in the manual section on how to install a psi4 binary with the psi4conda installer download site. The Anaconda package is available for Linux, Mac, Mac Silicon, Windows and WSL Windows, so every mainstream desktop platform is covered by a prebuilt binary.
Building from source is documented in the build FAQ, and the README notes that for the CMake adept there is a CMakeLists.txt in the repository root. So the build is CMake-based, and the FAQ page for build instructions is linked from the README rather than reproduced in it.
The platform list in the badges covers Linux, Linux ARM64, MacOS Intel, MacOS Silicon, Windows and Windows WSL, and the Python badge lists 3.10, 3.11, 3.12, 3.13 and 3.14. That range is worth checking against your environment before you start, because a quantum chemistry code is not something you want to discover a Python version conflict in the middle of a week-long computation.
The supported systems page in the manual is the reference for both the platform list and the Python list, so that is where to confirm the current state rather than trusting a badge.
Continuous integration, coverage, and the samples as tests
The project runs its builds on Azure DevOps, on Linux and Windows, and there is a codecov badge for both Python and C++ source code lines hit by running most of the test suite. The coverage definition is explicit: lines hit by running most of the test suite, which is a fair and honest description of what a coverage number in a scientific code means, since the interesting paths are the ones a test suite reaches with a small molecule.
The samples/ directory doubles as a test corpus. The sample inputs are linked in the README as also being in samples/, and the testsuite page documents them, so the same inputs that demonstrate a method are used to check that the method still gives the right answer. That is a good pattern for a scientific package, because the regression tests are then meaningful computations rather than assertions about function signatures.
The repository carries the artefacts of a long-lived project with a modernised build. There is an azure-pipelines.yml at the root and a .azure-pipelines/ directory, a CTestConfig.cmake and a cdash/ directory for test reporting, a cmake/ directory, and a conda/ directory with the packaging recipe, plus an environment.yml. The .pre-commit-config.yaml, .clang-format, .style.yapf, .isort.cfg and .lgtm.yml files cover the formatting of both languages, and codedeps.yaml and codemeta.json are the metadata files for dependency catalogues and for the machine readable software record.
The external/ directory is where the third-party libraries live, and THIRD-PARTY-LICENSES at the root is the file that tracks their terms, which is the practical counterpart of the LGPL licence on Psi4's own code.
How a project of this age is documented and supported
The README is a badge wall with a short prose core, which tells you the documentation has moved elsewhere and that the project expects you to follow.
The manual is the primary reference, and there are two versions of it. The master manual is at the bit.ly short link and is built nightly from the master branch, while the versioned manual at the 1.4.0 path is the last release. The distinction is the one to internalise: the nightly manual documents code that is on master, not code you have, and for a package where the difference between master and a release can be a method that changed default settings, that matters.
The user site is psicode.org and the download and install page is a separate site at psicode.netlify.com/installs/latest. Support runs through a Discourse forum at forum.psicode.org and a Slack workspace for development chat, and there is a technical support page in the manual introduction.
The developers page is worth noting because of what it says. The link text for it is interested developers, and the parenthetical says that a replacement page is needed, which is an honest admission that the page is out of date. The same line tells you that forking is welcome, that you should follow the GitHub contribution procedure, and there is a PRs welcome badge.
The forum, the Slack and the weekly release cadence together suggest an active project with a real user community rather than an academic curiosity. The last push was on 2026-10-15 and the most recent releases are v1.11 from 2026-06-29, v1.10.2 from 2026-06-18 and v1.10.1 from 2026-05-29.
Where Psi4 is the wrong choice
The first limitation is the abstraction level. Psi4 computes electronic structure, and it is not a chemistry package with a user interface. You do not pick Psi4 and click a molecule; you write a program that names the method, the basis set, the geometry, the convergence criteria and the properties, and you wait. The samples are the practical answer to that, but the first real calculation is a day of reading input files rather than a day of clicking.
The second is the build if you go the source route. The conda route is the one to take, because a from-source build of a scientific code with a large external/ directory, a C++ core with Pybind11 bindings, and a CMake build is a multi-hour job with a real chance of hitting a compiler or BLAS issue. The README points at the build FAQ, and that FAQ exists because the process has enough sharp edges to need one.
The third is the licence for some users. LGPL-3.0 is fine for academic and research use and for most commercial use, but a team that cannot ship a dynamically linked LGPL library, or that has a policy against it, should look at the alternatives before committing. The THIRD-PARTY-LICENSES file at the root is the place to start that check, because the dependencies carry their own terms and that file exists to record them.
The fourth is scope. Ab initio electronic structure is expensive, and Psi4's own claim of routinely running more than 2500 basis functions on multi-core machines tells you the scale it is designed for. If your problem is a large system with a cheap method, the right tool is a force field or a tight binding code, and Psi4 is the wrong expense.
And the fifth is documentation drift. The master manual is built nightly from master, so the documentation you find first may describe a version you do not have. A team that values reproducibility should read the versioned manual for the release they actually installed, not the one the search engine surfaced.
Editorial conclusion
Psi4 is a good pick for a computational chemistry group that wants an ab initio electronic structure code they can script, either through the Psithon input language or through the PsiAPI Python interface, because the same C++ core serves both and the conda distribution removes the build entirely; it is the wrong pick if you need a turnkey package for a specific study, since the input file is a program you write rather than a molecule you pick from a menu, and before you build it yourself you should check the Python version range, since the supported versions run from 3.10 to 3.14 and the manual page linked from the README is built nightly from master rather than from a release.
Frequently asked questions
What is Psi4 and how is it built?
Psi4 is an open-source suite of ab initio quantum chemistry programs for high-accuracy simulations of molecular properties. Computationally demanding portions are written in C++, many C++ classes are exported into Python via Pybind11, and a flexible Python driver sits on top, with the project routinely running computations above 2500 basis functions.
How do I install Psi4?
The primary route is a binary from conda, through either the psi4 Anaconda channel or conda-forge, with packages for Linux, Mac, Mac Silicon, Windows and WSL. Building from source is the alternative, using the CMake project at the repository root, and the build FAQ has the details.
What is the difference between Psithon and PsiAPI?
Psithon is the Python-like input language run as psi4 job.in, and PsiAPI is a Python library you import and script, run as python job.py. The same C++ core serves both, and the samples/ directory contains worked examples of each method in both styles.
Which Python versions does Psi4 support?
The README badge lists Python 3.10, 3.11, 3.12, 3.13 and 3.14, and the supported systems page in the manual is the reference for the current platform and Python list.
What licence is Psi4 released under?
LGPL-3.0, with the copyright held by the Psi4 Developers from 2007 to 2026, and a THIRD-PARTY-LICENSES file at the repository root recording the terms of code used from other parties.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/psi4-psi4)Was this useful?