# Roadmap

Broadly speaking, any form of purely symbolic mathematical computation is in scope for SymPy. However, there are a few things we plan to focus our development efforts on.

### The Assumptions System

The assumptions system handles how SymPy makes assumptions on expressions and does logical inference and simplification based on those assumptions (for instance, assuming an expression is "positive" or "integer"). The SymPy assumptions system is currently in a state of disarray, as there is a "new" system and an "old" system that need to be properly merged. However, because assumptions affect every part of the codebase, this is a challenging task.

### Code Generation

Code generation refers to the task of converting SymPy expressions into another language, such as C or Fortran, for the purposes of fast numerical evaluation. The goal with code generation is to be able to use SymPy to model a problem symbolically, and then seamlessly convert that symbolic model into fast code that can be numerically evaluated on real data. Our roadmap for code generation is to make that translation as seamless as possible, through things like higher level abstractions that reduce the amount of work needed by the end user, an optimization pipeline, which would allow SymPy to take advantage of its mathematical knowledge to create faster and more accurate code, and more tools to help solve domain specific problems.

### Performance

Performance is an important aspect in symbolic computation. SymPy often suffers in terms of performance due to it being written in pure Python. There are a few ways that SymPy can be made more performant. One is to more carefully benchmark and profile SymPy code, so that inefficiencies can be rooted out. This includes tooling to prevent performance regressions from ever occurring in the first place. Second is to have a fast symbolic core that can be optionally plugged in to make SymPy's core operations faster. The plan is to use the SymEngine library as an optional fast symbolic core for SymPy. SymEngine is a symbolic library written in C++, with an emphasis on performance. A third way SymPy can be made more performant is by implementing faster symbolic algorithms for various computations (see below).

### SymPy Live and SymPy Gamma

SymPy Live is a web application that runs a full SymPy Python session in the browser. It can be used standalone, and is also used in the SymPy documentation to allow readers to interactively evaluate the documentation examples. The backend of SymPy Live needs modernization, and there are several possible improvements for the frontend as well.

SymPy Gamma is a web application that takes a mathematical formula and performs many useful calculations on it, such as plotting, solving, simplifying, and symbolic integration. The goal of SymPy Gamma is to be an open source competitor to things like WolframAlpha. We aim to improve SymPy Gamma by adding more useful computations to the output, and by improving the parsing so that users do not need to know SymPy syntax to use it.

### Algorithmic Improvements

SymPy depends on a large array of symbolic computation algorithms to work. Many algorithms are already implemented, but quite a few are not. These include things like improved algorithms for symbolic integration, summations, simplification, polynomial manipulation, and equation solving, among many others. Improved algorithms will both increase the number of symbolic computations that SymPy is able to successfully compute, and, in many cases, greatly improve the performance of existing algorithms. A good resource for the sorts of things we want to implement is our Google Summer of Code ideas page.

### General Improvements

Aside from the above specific items, we are always aiming to improve SymPy in many ways. This includes things like

- fixing bugs
- better documentation
- improved development tooling
- new features
- better community outreach