# scimax: an Emacs starterkit for scientists that its author has stopped maintaining

> scimax is an Emacs starterkit that packages a working configuration for scientific programming and publishing, built around org-mode, Jupyter integration and LaTeX export. The judgement is that the configuration is still worth reading and reusing, but the project README now states that development is discontinued, so adopting it means owning the maintenance.

**jkitchin/scimax** — An emacs starterkit for scientists and engineers

- Repository: https://github.com/jkitchin/scimax
- Stars: 1,133 · Forks: 122
- Language: Emacs Lisp
- License: NOASSERTION
- Published: 2026-10-19 · Updated: 2026-10-19 · Language: en
- Canonical page: https://hysenlabs.com/projects/jkitchin-scimax

## The README opens with a discontinuation notice

Before anything else, the state of the project.

The NEWS section of the README is dated 2026-04-23 and the author explains that Emacs and scimax have been a central part of his work for over a decade, and that thanks to Claude Code he has been able to replicate almost everything he did in scimax in VS Code over the past few months, and that he no longer uses Emacs. The result is that he is discontinuing development of scimax. He says he will leave it here for others who still want to use it, but does not have current plans to maintain it further at this time, and thanks the people who contributed bug reports and pull requests.

That is an unusually clear statement, and it is the first thing a reader should know. The last push to the repository was on 2026-04-28, and the repository is not archived, so the code remains reachable and the configuration remains intact. But the project is a frozen artefact, not a moving dependency.

The prior entry, dated 2025-10-07, describes scimax 4.0 and is more positive. It notes that development has not been as vigorous in the two years since the last big update as in years past, that there were a few new modules such as org-db-audio and scimax-qr, and some refactoring of scimax-jupyter. The author offers the view that in some ways that stability is a feature of maturity. He also records renewed energy in scimax from the development of LLMs and their integration into Emacs with packages like gptel, and lists plans including an update to Emacs 31+, a scimax-gptel module that was not public at the time, a rewrite of org-db to enable semantic search across text, images, audio and more, and refactoring to make startup faster and maintenance easier.

Those plans are now historical. The April 2026 entry supersedes them.

## A configuration of Emacs for scientific programming and publishing

What scimax is, is best described in the author's own words: an Emacs starterkit for scientists and engineers, providing a comprehensive configuration of Emacs for scientific programming and publishing.

That phrase, comprehensive configuration, is the important qualifier. This is not a library and not a single tool. It is a complete Emacs setup, an opinionated one, that the author has used daily for his own work. The value is that the pieces are already wired together in a way that works, rather than that any individual piece is novel.

The scope is visible in the repository root. There are Jupyter integration files in `scimax-jupyter.el`, `scimax-jupyter.org` and `scimax-jupyter-r.org`, and a separate `scimax-jupyter-julia.org`. There is `scimax-latex.el` for LaTeX, `scimax-literate-programming.el`, `scimax-notebook.org` and `scimax-journal.el`. There is `scimax-lob/` and `scimax-lob.el` for literate programming, `scimax-elfeed.el` and `scimax-gitter.el` for feeds, `scimax-email.el`, `scimax-slack.el` and `scimax-ldap.el` for communication and lookup. `scimax-dashboard.el` is the dashboard feature, and `scimax-hydra.el` is a leader key style menu. There is `scimax-inkscape.el` for diagram work, `scimax-functional-text.el`, `scimax-link-thumbnails.el` and `scimax-editmarks.org` for editing, and `scimax-ivy.el` and `scimax-jinx.el` for completion.

Export support is there as well, with `ox-cmu/`, `ox-manuscript/` and `ox-twee2.el` providing org exporters, the last being described as an experimental exporter for org to twee, interactive fiction. There are `obipy-resources/`, `org-db-v2/`, `org-show/`, `python/` and `obipy` related directories, plus `examples/cmu-qualifier.org`, which suggests a conference talk written with the system.

The `ox-cmu/` and `ox-manuscript/` directories are the clearest statement of the audience. A manuscript exporter is for people who write papers, and a CMU exporter is for a specific institution's thesis format. This is a configuration built by somebody who publishes.

## Homebrew first, git clone as the fallback

The installation section names Homebrew as the preferred method, and it should work on macOS, Linux and Windows via WSL, with the details in a separate `homebrew-scimax` repository.

The tap comes first:

```bash
brew tap jkitchin/scimax
```

Then the default version:

```bash
brew install scimax
```

And the files straight from the git repository, which is the `--head` variant:

```bash
brew install --head scimax
```

The `--head` form tracks the repository rather than a tagged release, and given that the repository has no GitHub releases at all, that distinction matters more here than it would for a project with a release history.

The install output tells you how to load scimax in your init file, and the README shows what that looks like. For a Homebrew install, the line goes into `~/.emacs.d/init.el` or whatever file you use:

```emacs-lisp
(load "/usr/local/opt/scimax/share/emacs/site-lisp/scimax/init.el")
```

And the fuller example shows the three-part arrangement the author uses, a preload file for variables, the scimax init file itself, and then the user's own `user.el`:

```emacs-lisp
;; If you want preload variables
(load  "/Users/jkitchin/Dropbox/emacs/user/preload.el")

;; This is what homebrew installed
(load "/usr/local/opt/scimax/share/emacs/site-lisp/scimax/init.el")

;; This points to your user.el file
(load  "/Users/jkitchin/Dropbox/emacs/user/user.el")
```

The separation of the user directory from scimax itself was a potentially breaking change introduced for the Homebrew integration in scimax 3.0, and scimax now honours the built-in way of providing user files, for example in `.emacs` or `.emacs.d`.

The archived methods are still documented, and the simplest is to clone the repository and set up your init file to load the parts you want. The old shell installers for Mac, Linux and Windows are still in the repository as `install-scimax-mac.sh`, `install-scimax-linux.sh` and `install-scimax-win.sh`, though the README notes that the Mac route needed homebrew, git and emacs installed and told you to install your own Python and LaTeX.

## The Makefile shows how the project is built and tested

The build system is Cask, the Emacs package manager, and the `Makefile` at the repository root is a thin layer over it.

```make
test: clean
	${CASK_EXEC} ert-runner --reporter ert -l test/test.el

build:
	${CASK_EXEC} ${emacs} -batch -l ${INIT}

compile:
	${CASK_EXEC} ${emacs} -Q -batch -l ${INIT} -L "." -f batch-byte-compile *.el
```

The `test` target runs the ert test runner over `test/test.el` with the `ert` reporter, and it depends on `clean`, so a test run always starts from a clean state. The `build` target loads `init.el` in batch mode, and `compile` byte-compiles every `.el` file in the root. The `clean` target removes the `*.elc` files.

Two targets are worth noting. The `nouser` target sets `scimax-load-user-dir` to nil and loads the init file, which is how you run scimax without your own personal configuration, which is the right way to test whether something is scimax or is your own setup. And the `github` target is simply `open https://github.com/jkitchin/scimax`, which tells you the author's workflow assumes a desktop with a browser and a GUI Emacs.

There is a large commented-out block in the Makefile for an `org` target that would have moved an old `org-plus` directory into a dated `elpa` directory. The comment above it says the author is not really sure what it does, that `org-plus` is not used any more, and that it may be removed eventually. It is a small illustration of the state of a configuration that has been maintained by one person for a decade: everything is kept, including the parts that no longer work.

The `Makefile` also references `CASK ?= cask` and `CASK_EXEC ?= ${CASK} exec`, and a `packages.el` file at the repository root, which is where the list of Emacs packages the configuration pulls in lives.

## The org-db subsystem is the part with known issues

Several entries in the NEWS section point at the same subsystem, org-db, and its state is worth understanding before adopting the whole thing.

The 2021 entry describes org-db as indexing your org-files into sqlite so you can then search them, with a scimax-contacts add-on to help find and use contacts. The 2023 scimax 3.0 entry says the org-db code has been expanded and includes full-text and image search, and that it provides an org-db-agenda interface. But it also says, in the same breath, that this code is still just useful enough, that although the author uses it almost daily it is still not perfect and has some issues that make it likely he will never separate it from scimax.

The 2025 entry mentions a rewrite of org-db to enable semantic search across text, images, audio and more, and a new module called org-db-audio. The repository root contains an `org-db-v2/` directory, which suggests the rewrite was in progress.

The author is candid about this. A subsystem that has issues, is used daily, and is not going to be extracted into a separate package is a different thing from a mature independent project. If you adopt scimax, you are adopting org-db in whatever state it is in, and the README's own assessment is that it will not improve without the author returning to it.

The lighter-weight parts of the configuration are in a better position. The 2023 release brought `scimax-org-table.el` with convenience functions for tables, `scimax-projectile.el` with projectile integration, `scimax-org-attachments.el` with org-attachment enhancements, `scimax-slack.el` for Slack integration, `scimax-ob-flycheck.el` for integrating flycheck with source blocks, which is marked experimental, and `ox-twee2.el`, the experimental twee exporter. The 2.0 release had overhauled IPython, added the dashboard, an inkscape link, link thumbnails, and functional text.

The pattern across the history is that the core configuration and the org-mode editing features have been stable, and the newest subsystems are the ones marked experimental.

## A licence to read, and a codebase to inherit

The licence is reported as a custom one that GitHub cannot classify, and there is a `LICENSE` file at the repository root, which is the text that governs. That is worth reading before you base a workflow on it, and this is a licensing observation rather than legal advice.

The broader question for a project in this position is ownership. The author has been explicit that he is discontinuing development and that his efforts have moved elsewhere. A configuration like this is a large body of decisions, Emacs Lisp code that encodes one person's habits, key bindings, package versions and directory layout.

That cuts two ways, and both are worth stating plainly. It is a serious advantage as a reference: a working scientific Emacs setup written by somebody who does the work, with the parts wired together, is more instructive than any tutorial. And it is a liability as a dependency: there is nobody else who knows why a particular package version is pinned, and when a package changes its API, the person who understood the workaround is not the person who will fix it.

The repository state reflects the second point. There is an `archive/` directory at the root, and the project will not be taking further contributions.

For a research group, the most likely productive use of this repository is not installation but reading. The manual is at `./scimax.org` in the repository, and the individual module documentation is written as org files, `scimax-jupyter.org`, `scimax-notebook.org`, `scimax-editmarks.org` and `scimax-jupyter-julia.org` among them, which means you can read the same literate-programming style the configuration is meant to produce.

The author's own framing of the situation is that the stability was in some ways a feature of maturity. That is a fair description of the code. It is less a fair description of the maintenance outlook.

## Conclusion

scimax fits a scientist or engineer who wants a complete, coherent Emacs setup for research and publishing and is prepared to maintain it themselves, and it fits anyone studying the configuration as a worked example of org-mode based research workflows. It does not fit a team expecting an actively developed starterkit, because the author announced in April 2026 that development is discontinued, and it does not fit a newcomer who wants a supported starting point rather than a maintained one. Verify first that the Emacs version you run is one the configuration targets, since the last release notes discuss moving to Emacs 31+, that the Homebrew formula and the git repository agree on what you are installing, since the `--head` variant tracks the repository rather than a tagged release, and that the pieces you actually depend on still work with the current versions of the packages it pulls in.

## FAQ

### Is scimax still maintained?

No. The README's NEWS entry dated 2026-04-23 states that the author is discontinuing development of scimax, will leave it in place for others who still want to use it, and has no current plans to maintain it further. The last push to the repository was on 2026-04-28.

### How do I install scimax?

Homebrew is the preferred method. Run `brew tap jkitchin/scimax` and then `brew install scimax`, or `brew install --head scimax` for the files from the git repository. You can also clone the repository and load the parts you want from your init file.

### What does scimax include for scientific work in Emacs?

The configuration covers org-mode based research and publishing, with Jupyter integration including R and Julia variants, LaTeX support, literate programming, a journal, exporters for a manuscript, a CMU thesis format and an experimental interactive fiction exporter, plus org-db for indexing and searching your org files.

### How is scimax tested?

The Makefile's `test` target runs the Emacs ert test runner with the ert reporter over `test/test.el`, using Cask to provide the environment, and it depends on `clean` so the run starts from a clean state.

### What are the known issues with scimax?

The README describes the org-db subsystem as still just useful enough, not perfect, with known issues that make it likely to never be separated from scimax. The 2025 plans for a semantic-search rewrite and a scimax-gptel module with tool and MCP integration for scientific writing were listed as underway, and the repository contains an `org-db-v2/` directory.

## Sources

- [Issues](https://github.com/jkitchin/scimax/issues)
- [jkitchin/scimax on GitHub](https://github.com/jkitchin/scimax)
- [README](https://github.com/jkitchin/scimax/blob/master/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/jkitchin-scimax