Install from Source Code#

Building Sage from the source code has the major advantage that your install will be optimized for your particular computer and should therefore offer better performance and compatibility than a binary install.

Moreover, it offers you full development capabilities: you can change absolutely any part of Sage or the packages on which it depends, and recompile the modified parts.

See the file README.md in SAGE_ROOT for information on supported platforms and step-by-step instructions.

The following sections provide some additional details. Most users will not need to read them. Some familiarity with the use of the Unix command line may be required to build Sage from the source code.

Installation steps#

Follow the procedure in the file README.md in SAGE_ROOT.
If you wish to prepare for having to build Sage in an environment without sufficient Internet connectivity:
- After running configure, you can use make download to force downloading packages before building. After this, the packages are in the subdirectory upstream.
- Alternatively, instead of cloning the git repository, you can download a self-contained release tarball for any stable release from the Sage project’s GitHub Releases. Use the file named sage-x.y.tar.gz (1.25 GB as of Sage 10.2) in the Release Assets, which contains a prepopulated subdirectory upstream.
  
  After downloading the source tarball sage-x.y.tar.gz into a directory ~/sage/:
```
$ cd ~/sage/
$ tar xf sage-x.y.tar.gz  # adapt x.y; takes a while
```
  This creates the subdirectory sage-x.y. Now change into it:
```
$ cd sage-x.y/  # adapt x.y
```
  Note
  
  On Windows, it is crucial that you unpack the source tree from the WSL $bash$ using the WSL $tar$ utility and not using other Windows tools (including mingw).
  
  This is because the Sage source tree contains symbolic links, and the build will not work if Windows line endings rather than UNIX line endings are used.
- The Sage mirrors also provide such self-contained tarballs for all stable releases and additionally for all development releases.
Additional remarks: You do not need to be logged in as root, since no files are changed outside of the SAGE_ROOT directory. In fact, it is inadvisable to build Sage as root, as the root account should only be used when absolutely necessary and mistyped commands can have serious consequences if you are logged in as root.

Typing make performs the usual steps for each Sage’s dependency, but installs all the resulting files into the installation prefix. Depending on the age and the architecture of your system, it can take from a few tens of minutes to several hours to build Sage from source. On really slow hardware, it can even take a few days to build Sage.

Each component of Sage has its own build log, saved in SAGE_ROOT/logs/pkgs. If the build of Sage fails, you will see a message mentioning which package(s) failed to build and the location of the log file for each failed package. If this happens, then paste the contents of these log file(s) to the Sage support newsgroup at https://groups.google.com/group/sage-support. If the log files are very large (and many are), then don’t paste the whole file, but make sure to include any error messages. It would also be helpful to include the type of operating system (Linux, macOS, Solaris, OpenSolaris, or any other system), the version and release date of that operating system and the version of the copy of Sage you are using. (There are no formal requirements for bug reports – just send them; we appreciate everything.)

See Make targets for some targets for the make command and Environment variables for additional information on useful environment variables used by Sage.
To start Sage, you can now simply type from Sage’s home directory:
```
$ ./sage
```
You should see the Sage prompt, which will look something like this:
```
$ sage
┌────────────────────────────────────────────────────────────────────┐
│ SageMath version 8.8, Release Date: 2019-06-26                     │
│ Using Python 3.10.4. Type "help()" for help.                       │
└────────────────────────────────────────────────────────────────────┘
sage:
```
Note that Sage should take well under a minute when it starts for the first time, but can take several minutes if the file system is slow or busy. Since Sage opens a lot of files, it is preferable to install Sage on a fast filesystem if possible.

Just starting successfully tests that many of the components built correctly. Note that this should have been already automatically tested during the build process. If the above is not displayed (e.g., if you get a massive traceback), please report the problem, e.g., at https://groups.google.com/group/sage-support.

After Sage has started, try a simple command:
```
sage: 2 + 2
4
```
Or something slightly more complicated:
```
sage: factor(2005)
5 * 401
```
Optional, but highly recommended: Test the install by typing ./sage --testall. This runs most examples in the source code and makes sure that they run exactly as claimed. To test all examples, use ./sage --testall --optional=all --long; this will run examples that take a long time, and those that depend on optional packages and software, e.g., Mathematica or Magma. Some (optional) examples will therefore likely fail.

Alternatively, from within $SAGE_ROOT, you can type make test (respectively make ptest) to run all the standard test code serially (respectively in parallel).

Testing the Sage library can take from half an hour to several hours, depending on your hardware. On slow hardware building and testing Sage can even take several days!
Optional: Check the interfaces to any other software that you have available. Note that each interface calls its corresponding program by a particular name: Mathematica is invoked by calling math, Maple by calling maple, etc. The easiest way to change this name or perform other customizations is to create a redirection script in $SAGE_ROOT/local/bin. Sage inserts this directory at the front of your PATH, so your script may need to use an absolute path to avoid calling itself; also, your script should pass along all of its arguments. For example, a maple script might look like:
```
#!/bin/sh

exec /etc/maple10.2/maple.tty "$@"
```
Optional: There are different possibilities to make using Sage a little easier:
- Make a symbolic link from /usr/local/bin/sage (or another directory in your PATH) to SAGE_ROOT/sage:
```
$ ln -s /path/to/sage_root/sage /usr/local/bin/sage
```
  Now simply typing sage from any directory should be sufficient to run Sage.
- Copy SAGE_ROOT/sage to a location in your PATH. If you do this, make sure you edit the line:
```
#SAGE_ROOT=/path/to/sage-version
```
  at the beginning of the copied sage script according to the direction given there to something like:
```
SAGE_ROOT=<SAGE_ROOT>
```
  (note that you have to change <SAGE_ROOT> above!). It is best to edit only the copy, not the original.
- For KDE users, create a bash script called sage containing the lines (note that you have to change <SAGE_ROOT> below!):
```
#!/usr/bin/env bash

konsole -T "sage" -e <SAGE_ROOT>/sage
```
  make it executable:
```
$ chmod a+x sage
```
  and put it somewhere in your PATH.
  
  You can also make a KDE desktop icon with this line as the command (under the Application tab of the Properties of the icon, which you get my right clicking the mouse on the icon).
- On Linux and macOS systems, you can make an alias to SAGE_ROOT/sage. For example, put something similar to the following line in your .bashrc file:
```
alias sage=<SAGE_ROOT>/sage
```
  (Note that you have to change <SAGE_ROOT> above!) Having done so, quit your terminal emulator and restart it. Now typing sage within your terminal emulator should start Sage.
Optional: Install optional Sage packages and databases. See the list of optional packages in the reference manual for detailed information, or type sage --optional (this requires an Internet connection).

Then type sage -i <package-name> to automatically download and install a given package.
Have fun! Discover some amazing conjectures!

Make targets#

To build Sage from scratch, you would typically execute make in Sage’s home directory to build Sage and its documentation in HTML format, suitable for viewing in a web browser.

The make command is pretty smart, so if your build of Sage is interrupted, then running make again should cause it to pick up where it left off. The make command can also be given options, which control what is built and how it is built:

make build builds Sage: it compiles all of the Sage packages. It does not build the documentation.
make doc builds Sage’s documentation in HTML format. Note that this requires that Sage be built first, so it will automatically run make build first. Thus, running make doc is equivalent to running make.
make doc-pdf builds Sage’s documentation in PDF format. This also requires that Sage be built first, so it will automatically run make build.
make doc-html-no-plot builds Sage’s documentation in html format but skips the inclusion of graphics auto-generated using the .. PLOT markup and the sphinx_plot function. This is primarily intended for use when producing certain binary distributions of Sage, to lower the size of the distribution. As of this writing (December 2014, Sage 6.5), there are only a few such plots, adding about 4M to the local/share/doc/sage/ directory. In the future, this may grow, of course. Note: after using this, if you want to build the documentation and include the pictures, you should run make doc-uninstall, because the presence, or lack, of pictures is cached in the documentation output. You can benefit from this no-plot feature with other make targets by doing export SAGE_DOCBUILD_OPTS+=' --no-plot'
make ptest and make ptestlong: these run Sage’s test suite. The first version skips tests that need more than a few seconds to complete and those which depend on optional packages or additional software. The second version includes the former, and so it takes longer. The “p” in ptest stands for “parallel”: tests are run in parallel. If you want to run tests serially, you can use make test or make testlong instead. If you want to run tests depending on optional packages and additional software, you can use make testall, make ptestall, make testalllong, or make ptestalllong.
make doc-uninstall and make doc-clean each remove several directories which are produced when building the documentation.
make distclean restores the Sage directory to its state before doing any building: it is almost equivalent to deleting Sage’s entire home directory and unpacking the source tarfile again, the only difference being that the .git directory is preserved, so git branches are not deleted.

Environment variables#

Sage uses several environment variables to control its build process. Most users won’t need to set any of these: the build process just works on many platforms. (Note though that setting MAKE, as described below, can significantly speed up the process.) Building Sage involves building many packages, each of which has its own compilation instructions.

Standard environment controlling the build process#

Here are some of the more commonly used variables affecting the build process:

MAKE#

One useful setting for this variable when building Sage is MAKE='make -jNUM' to tell the make program to run NUM jobs in parallel when building. Note that some Sage packages may not support this variable.

Some people advise using more jobs than there are CPU cores, at least if the system is not heavily loaded and has plenty of RAM; for example, a good setting for NUM might be between 1 and 1.5 times the number of cores. In addition, the -l option sets a load limit: MAKE='make -j4 -l5.5, for example, tells make to try to use four jobs, but to not start more than one job if the system load average is above 5.5. See the manual page for GNU make: Command-line options and Parallel building.

V#

If set to 0, silence the build. Instead of showing a detailed compilation log, only one line of output is shown at the beginning and at the end of the installation of each Sage package. To see even less output, use:

$ make -s V=0

(Note that the above uses the syntax of setting a Makefile variable.)

CC#: While some programs allow you to use this to specify your C compiler, not every Sage package recognizes this. If GCC is installed within Sage, CC is ignored and Sage’s gcc is used instead.

CPP#: Similarly, this will set the C preprocessor for some Sage packages, and similarly, using it is likely quite risky. If GCC is installed within Sage, CPP is ignored and Sage’s cpp is used instead.

CXX#: Similarly, this will set the C++ compiler for some Sage packages, and similarly, using it is likely quite risky. If GCC is installed within Sage, CXX is ignored and Sage’s g++ is used instead.

FC#: Similarly, this will set the Fortran compiler. This is supported by all Sage packages which have Fortran code. However, for historical reasons, the value is hardcoded during the initial make and subsequent changes to $FC might be ignored (in which case, the original value will be used instead). If GCC is installed within Sage, FC is ignored and Sage’s gfortran is used instead.

CFLAGS#

CXXFLAGS#

FCFLAGS#: The flags for the C compiler, the C++ compiler and the Fortran compiler, respectively. The same comments apply to these: setting them may cause problems, because they are not universally respected among the Sage packages. Note also that export CFLAGS="" does not have the same effect as unset CFLAGS. The latter is preferable.

CPPFLAGS#

LDFLAGS#

CXXFLAG64#

LDFLAG64#

LD#: Similar comments apply to these compiler and linker flags.

Sage-specific environment variables controlling the build process#

SAGE_SERVER#

The Sage source tarball already includes the sources for all standard packages, that is, it allows you to build Sage without internet connection. The git repository, however, does not contain the source code for third-party packages. Instead, it will be downloaded as needed (note: you can run make download to force downloading packages before building).

If SAGE_SERVER is set, the specified Sage mirror is contacted first. Note that Sage will search the directory SAGE_SERVER/spkg/upstream for upstream tarballs.

If downloading a file from there fails or SAGE_SERVER is not set, files will be attempted to download from release assets of the Sage GitHub repository.

If that fails too, the Sage mirror network is contacted to determine the nearest mirrors.

This sequence of operations is defined by the files in the directory SAGE_ROOT/.upstream.d.

SAGE_NUM_THREADS#

If set to a number, then when rebuilding with sage -b or parallel doctesting with sage -t -p 0, use at most this many threads.

If this is not set, then determine the number of threads using the value of the MAKE (see above) or MAKEFLAGS environment variables. If none of these specifies a number of jobs,

sage -b only uses one thread
sage -t -p 0 uses a default of the number of CPU cores, with a maximum of 8 and a minimum of 2.

When sage -t -p runs under the control of the GNU make jobserver, then Sage will request as most this number of job slots.

SAGE_CHECK#: If set to yes, then during the build process, or when installing packages manually, run the test suite for each package which has one, and stop with an error if tests are failing. If set to warn, then only a warning is printed in this case. See also SAGE_CHECK_PACKAGES.

SAGE_CHECK_PACKAGES#: If SAGE_CHECK is set to yes, then the default behavior is to run test suites for all spkgs which contain them. If SAGE_CHECK_PACKAGES is set, it should be a comma-separated list of strings of the form package-name or !package-name. An entry package-name means to run the test suite for the named package regardless of the setting of SAGE_CHECK. An entry !package-name means to skip its test suite. So if this is set to ppl,!python3, then always run the test suite for PPL, but always skip the test suite for Python 3.

Note

As of Sage 9.1, the test suites for the Python 2 and 3 spkgs fail on most platforms. So when this variable is empty or unset, Sage uses a default of !python2,!python3.

SAGE_INSTALL_GCC#: Obsolete, do not use, to be removed

SAGE_INSTALL_CCACHE#

By default Sage doesn’t install ccache, however by setting SAGE_INSTALL_CCACHE=yes Sage will install ccache. Because the Sage distribution is quite large, the maximum cache is set to 4G. This can be changed by running sage -sh -c "ccache --max-size=SIZE", where SIZE is specified in gigabytes, megabytes, or kilobytes by appending a “G”, “M”, or “K”.

Sage does not include the sources for ccache since it is an optional package. Because of this, it is necessary to have an Internet connection while building ccache for Sage, so that Sage can pull down the necessary sources.

SAGE_DEBUG#

Controls debugging support. There are three different possible values:

Not set (or set to anything else than “yes” or “no”): build binaries with debugging symbols, but no special debug builds. This is the default. There is no performance impact, only additional disk space is used.
SAGE_DEBUG=no: no means no debugging symbols (that is, no gcc -g), which saves some disk space.
SAGE_DEBUG=yes: build debug versions if possible (in particular, Python is built with additional debugging turned on and Singular is built with a different memory manager). These will be notably slower but, for example, make it much easier to pinpoint memory allocation problems.

Instead of using SAGE_DEBUG one can configure with --enable-debug={no|symbols|yes}.

SAGE_PROFILE#: Controls profiling support. If this is set to yes, profiling support is enabled where possible. Note that Python-level profiling is always available; this option enables profiling in Cython modules.

SAGE_BUILD_DIR#: The default behavior is to build each spkg in a subdirectory of $SAGE_ROOT/local/var/tmp/sage/build/; for example, build version 7.27.0 of ipython in the directory $SAGE_ROOT/local/var/tmp/sage/build/ipython-7.27.0/. If this variable is set, then build in $SAGE_BUILD_DIR/ipython-7.27.0/ instead. If the directory $SAGE_BUILD_DIR does not exist, it is created. As of this writing (Sage 4.8), when building the standard Sage packages, 1.5 gigabytes of free space are required in this directory (or more if SAGE_KEEP_BUILT_SPKGS=yes – see below); the exact amount of required space varies from platform to platform. For example, the block size of the file system will affect the amount of space used, since some spkgs contain many small files.

Warning

The variable SAGE_BUILD_DIR must be set to the full path name of either an existing directory for which the user has write permissions, or to the full path name of a nonexistent directory which the user has permission to create. The path name must contain no spaces.

SAGE_KEEP_BUILT_SPKGS#: The default behavior is to delete each build directory – the appropriate subdirectory of $SAGE_ROOT/local/var/tmp/sage/build or $SAGE_BUILD_DIR – after each spkg is successfully built, and to keep it if there were errors installing the spkg. Set this variable to yes to keep the subdirectory regardless. Furthermore, if you install an spkg for which there is already a corresponding subdirectory, for example left over from a previous build, then the default behavior is to delete that old subdirectory. If this variable is set to yes, then the old subdirectory is moved to $SAGE_ROOT/local/var/tmp/sage/build/old/ (or $SAGE_BUILD_DIR/old), overwriting any already existing file or directory with the same name.

Note

After a full build of Sage (as of version 4.8), these subdirectories can take up to 6 gigabytes of storage, in total, depending on the platform and the block size of the file system. If you always set this variable to yes, it can take even more space: rebuilding every spkg would use double the amount of space, and any upgrades to spkgs would create still more directories, using still more space.

Note

In an existing Sage installation, running sage -i -s <package-name> or sage -f -s <package-name> installs the spkg <package-name> and keeps the corresponding build directory; thus setting SAGE_KEEP_BUILT_SPKGS to yes mimics this behavior when building Sage from scratch or when installing individual spkgs. So you can set this variable to yes instead of using the -s flag for sage -i and sage -f.

SAGE_FAT_BINARY#: To build binaries that will run on the widest range of target CPUs set this variable to yes before building Sage or configure with --enable-fat-binary. This does not make the binaries relocatable, it only avoids newer CPU instruction set extensions. For relocatable (=can be moved to a different directory) binaries, you must use https://github.com/sagemath/binary-pkg

SAGE_SUDO#

Set this to sudo -E or to any other command prefix that is necessary to write into a installation hierarchy (SAGE_LOCAL) owned by root or another user. Note that this command needs to preserve environment variable settings (plain sudo does not).

Not all Sage packages currently support SAGE_SUDO.

Therefore this environment variable is most useful when a system administrator wishes to install an additional Sage package that supports SAGE_SUDO, into a root-owned installation hierarchy (SAGE_LOCAL).

Environment variables controlling the documentation build#

SAGE_DOCBUILD_OPTS#

The value of this variable is passed as an argument to sage --docbuild all html or sage --docbuild all pdf when you run make, make doc, or make doc-pdf. For example:

add --no-plot to this variable to avoid building the graphics coming from the .. PLOT directive within the documentation,
add --no-preparsed-examples to only show the original Sage code of “EXAMPLES” blocks, suppressing the tab with the preparsed, plain Python version, or
add --include-tests-blocks to include all “TESTS” blocks in the reference manual.

Run sage --docbuild help to see the full list of options.

SAGE_SPKG_INSTALL_DOCS#: If set to yes, then install package-specific documentation to $SAGE_ROOT/local/share/doc/PACKAGE_NAME/ when an spkg is installed. This option may not be supported by all spkgs. Some spkgs might also assume that certain programs are available on the system (for example, latex or pdflatex).

SAGE_USE_CDNS#: If set to yes, then build the documentation using CDNs (Content Distribution Networks) for scripts necessary for HTML documentation, such as MathJax.

SAGE_LIVE_DOC#: If set to yes, then build live Sage documentation. If the Make live button on any webpage of the live doc is clicked, every example code gets a CodeMirror code cell runnable via Thebe. Thebe is responsible in sending the code to the Sage computing environment built by Binder and showing the output result. The Sage computing environment can be specified to either a Binder repo or a local Jupyter server. The environment variable SAGE_JUPYTER_SERVER is used for this purpose.

SAGE_JUPYTER_SERVER#

Set this to either binder, binder:repo with repo specifying a Binder repo or the URL to a local Jupyter server.

binder refers to Sage’s official Binder repo. This is assumed if the environment variable SAGE_JUPYTER_SERVER is not set.
binder:repo specifies a Binder repo with repo, which is a GitHub repository name, optionally added with a branch name with / separator.
To use a local Jupyter server instead of Binder, then set the URL to SAGE_JUPYTER_SERVER and the secret token to environment variable SAGE_JUPYTER_SERVER_TOKEN, which can be left unset if the default token secret is used. If the live doc was built with SAGE_JUPYTER_SERVER=https://localhost:8889, run a local Jupyter server by
```
./sage --notebook=jupyterlab \
       --ServerApp.token='secret' \
       --ServerApp.allow_origin='null' \
       --ServerApp.disable_check_xsrf=true \
       --ServerApp.port=8889 \
       --ServerApp.open_browser=false
```
before opening the Sage documentation webpage.

Environment variables dealing with specific Sage packages#

SAGE_MATPLOTLIB_GUI#: If set to anything non-empty except no, then Sage will attempt to build the graphical backend when it builds the matplotlib package.

OPENBLAS_CONFIGURE#: Adds additional configuration flags for the OpenBLAS package that gets added to the make command. (see Issue #23272)

PARI_CONFIGURE#: Use this to pass extra parameters to PARI’s Configure script, for example to specify graphics support (which is disabled by default). See the file build/pkgs/pari/spkg-install.in for more information.

SAGE_TUNE_PARI#: If yes, enable PARI self-tuning. Note that this can be time-consuming. If you set this variable to “yes”, you will also see this: WARNING: Tuning PARI/GP is unreliable. You may find your build of PARI fails, or PARI/GP does not work properly once built. We recommend to build this package with SAGE_CHECK="yes".

PARI_MAKEFLAGS#: The value of this variable is passed as an argument to the $MAKE command when compiling PARI.

Environment variables dealing with doctesting#

SAGE_TIMEOUT#: Used for Sage’s doctesting: the number of seconds to allow a doctest before timing it out. If this isn’t set, the default is 300 seconds (5 minutes).

SAGE_TIMEOUT_LONG#: Used for Sage’s doctesting: the number of seconds to allow a doctest before timing it out, if tests are run using sage -t --long. If this isn’t set, the default is 1800 seconds (30 minutes).

SAGE_TEST_GLOBAL_ITER#

SAGE_TEST_ITER#: These can be used instead of passing the flags --global-iterations and --file-iterations, respectively, to sage -t. Indeed, these variables are only used if the flags are unset. Run sage -t -h for more information on the effects of these flags (and therefore these variables).

Environment variables set within Sage environments#

Sage sets some other environment variables. The most accurate way to see what Sage does is to first run env from a shell prompt to see what environment variables you have set. Then run sage --sh -c env to see the list after Sage sets its variables. (This runs a separate shell, executes the shell command env, and then exits that shell, so after running this, your settings will be restored.) Alternatively, you can peruse the shell script src/bin/sage-env.

Sage also has some environment-like settings. Some of these correspond to actual environment variables while others have names like environment variables but are only available while Sage is running. To see a list, execute sage.env.[TAB] while running Sage.

Installation in a multiuser environment#

This section addresses the question of how a system administrator can install a single copy of Sage in a multi-user computer network.

Using sudo, create the installation directory, for example, /opt/sage/sage-x.y. We refer to it as SAGE_LOCAL in the instructions below. Do not try to install into a directory that already contains other software, such as /usr/local:
```
$ sudo mkdir -p SAGE_LOCAL
```

Make the directory writable for you and readable by everyone:

$ sudo chown $(id -un) SAGE_LOCAL
$ sudo chmod 755 SAGE_LOCAL

Build and install Sage, following the instructions in README.md, using the configure option --prefix=SAGE_LOCAL.

Do not use sudo for this step; building Sage must be done using your normal user account.
Optionally, create a symbolic link to the installed sage script in a directory that is in the users’ PATH, for example /usr/local/bin:
```
$ sudo ln -s SAGE_LOCAL/bin/sage /usr/local/bin/sage
```
Optionally, change permissions to prevent accidental changes to the installation by yourself:
```
$ sudo chown -R root SAGE_LOCAL
```

Upgrading the system and upgrading Sage#

Caveats when upgrading system packages#

When Sage has been installed from source, it will make use of various system packages; in particular, it will link to shared libraries provided by the system.

The system’s package manager does not keep track of the applications that make use of the shared libraries. Therefore indiscriminate upgrades of system packages can break a Sage installation.

This can always be fixed by a full rebuild:

$ make distclean && make build

But this time-consuming step can often be avoided by just reinstalling a few packages. The command make -j list-broken-packages assists with this:

$ make -j list-broken-packages
make --no-print-directory auditwheel_or_delocate-no-deps
...
# Checking .../local/var/lib/sage/installed/bliss-0.73+debian-1+sage-2016-08-02.p0
...
Checking shared library file '.../local/lib/libumfpack.dylib'
Checking shared library file '.../local/var/tmp/sage/build/suitesparse-5.10.1/src/lib/libsliplu.1.0.2.dylib'
Error during installcheck of 'suitesparse': .../local/var/tmp/sage/build/suitesparse-5.10.1/src/lib/libsliplu.1.0.2.dylib
...
Uninstall broken packages by typing:

    make lcalc-SAGE_LOCAL-uninstall;
    make ratpoints-SAGE_LOCAL-uninstall;
    make r-SAGE_LOCAL-uninstall;
    make suitesparse-SAGE_LOCAL-uninstall;

After running the suggested commands, run:

$ make build

Upgrading Sage using a separate git worktree#

When you have a working installation of Sage built from source and wish to try out a new version, we strongly recommend to use a separate git worktree, so that you can keep using your existing installation when something goes wrong.

Start from the directory created when you used git clone, perhaps ~/sage/sage/. Let’s verify that this is indeed a git repository by looking at the hidden .git subdirectory. It will looks like this, but the exact contents can vary:

[alice@localhost sage]$ ls .git
COMMIT_EDITMSG HEAD           branches       description    gitk.cache
index          logs           packed-refs    FETCH_HEAD     ORIG_HEAD
config         hooks          info           objects        refs

Good. Now let’s see what worktrees already exist:

[alice@localhost sage]$ git worktree list
/home/alice/sage/sage                     c0ffeefe10 [master]

We see just one line, the directory created when you used git clone. We will call this the “main worktree” from now on. Next to the directory, you can see the abbreviated commit sha and the name of the branch that we’re on (master).

To try out a new version of Sage, let’s fetch it first from the main repository:

[alice@localhost sage]$ git fetch upstream 10.3.beta8
From https://github.com/sagemath/sage
 * tag                     10.3.beta8 -> FETCH_HEAD

Now let’s create a new worktree. We need a name for it; it should start with worktree- but can be anything after that. Experience shows that worktrees are often repurposed later, and because a directory containing a Sage installation cannot be moved without breaking the installation in it, it may be a good idea to choose a memorable name without much meaning:

[alice@localhost sage]$ git worktree add worktree-purple FETCH_HEAD
Preparing worktree (detached HEAD 30b3d78fac)
Updating files: 100% (11191/11191), done.
HEAD is now at 30b3d78fac Updated SageMath version to 10.3.beta8

We now have a subdirectory worktree-purple. This is a “linked worktree”:

[alice@localhost sage]$ git worktree list
/home/alice/sage/sage                     c0ffeefe10 [master]
/home/alice/sage/sage/worktree-purple     30b3d78fac (detached HEAD)
[alice@localhost sage]$ cd worktree-purple
[alice@localhost worktree-purple]$ cat VERSION.txt
SageMath version 10.3.beta8, Release Date: 2024-02-13

All worktrees created in this way share the same repository, so they have access to all branches:

[alice@localhost worktree-purple]$ git --no-pager branch -v
* (no branch) 30b3d78fac Updated SageMath version to 10.3.beta8
+ master      2a9a4267f9 Updated SageMath version to 10.2

In fact, .git here is not a directory, just a hidden file:

[alice@localhost worktree-purple]$ ls -l .git
-rw-r--r--  1 alice  staff  59 Feb 20 18:16 .git

In the new worktree, we now build Sage from scratch. This is completely independent of and will not disrupt your existing working installation in the main worktree.

We will refer again to the step-by-step instructions from the file README.md. Our worktree worktree-purple is the SAGE_ROOT for this purpose.

One thing that we can share between worktrees without worry is the directory upstream, where Sage caches downloaded archives of packages. To have the new worktree share it with the main worktree, let’s create a symbolic link. This is an optional step that will avoid re-downloading files that you already have:

[alice@localhost worktree-purple]$ ln -s ../upstream/ .

Now let’s build Sage, starting with the step:

[alice@localhost worktree-purple]$ make configure

Refer to the file README.md for the following steps.

Install from Source Code#

Prerequisites#

Disk space and memory#

Software prerequisites and recommended packages#

Linux system package installation#

macOS prerequisites#

macOS package installation#

WSL prerequisites#

Ubuntu on Windows Subsystem for Linux (WSL) prerequisite installation#

WSL permission denied error when building `packaging` package#

WSL post-installation notes#

Other platforms#

Notes on using conda#

Tcl/Tk (and system’s Python)#

Tcl/Tk (and Sage’s own Python)#

Installation steps#

Make targets#

Environment variables#

Standard environment controlling the build process#

Sage-specific environment variables controlling the build process#

Environment variables controlling the documentation build#

Environment variables dealing with specific Sage packages#

Environment variables dealing with doctesting#

Environment variables set within Sage environments#

Installation in a multiuser environment#

Upgrading the system and upgrading Sage#

Caveats when upgrading system packages#

Upgrading Sage using a separate git worktree#

Install from Source Code#

Prerequisites#

Disk space and memory#

Software prerequisites and recommended packages#

Linux system package installation#

macOS prerequisites#

macOS package installation#

WSL prerequisites#

Ubuntu on Windows Subsystem for Linux (WSL) prerequisite installation#

WSL permission denied error when building packaging package#

WSL post-installation notes#

Other platforms#

Notes on using conda#

Tcl/Tk (and system’s Python)#

Tcl/Tk (and Sage’s own Python)#

Installation steps#

Make targets#

Environment variables#

Standard environment controlling the build process#

Sage-specific environment variables controlling the build process#

Environment variables controlling the documentation build#

Environment variables dealing with specific Sage packages#

Environment variables dealing with doctesting#

Environment variables set within Sage environments#

Installation in a multiuser environment#

Upgrading the system and upgrading Sage#

Caveats when upgrading system packages#

Upgrading Sage using a separate git worktree#

WSL permission denied error when building `packaging` package#