diff --git a/README.md b/README.md
index 4b163c7414..0b93f82501 100644
--- a/README.md
+++ b/README.md
@@ -42,7 +42,8 @@ installation and postprocessing procedures. Its features include:
 * Multi-physics simulations
   * [Self-gravitating gas dynamics](https://github.com/trixi-framework/paper-self-gravitating-gas-dynamics)
 * Shared-memory parallelization via multithreading
-* Visualization of results with Julia-only tools (2D) or ParaView/VisIt (2D/3D)
+* Visualization of results with Julia-only tools ([Trixi2Img](https://github.com/trixi-framework/Trixi2Img.jl))
+  or ParaView/VisIt ([Trixi2Vtk](https://github.com/trixi-framework/Trixi2Vtk.jl))
 
 
 ## Installation
@@ -69,13 +70,13 @@ within the cloned directory:
 ```bash
 git clone git@github.com:trixi-framework/Trixi.jl.git
 cd Trixi.jl
-julia --project=. -e 'import Pkg; Pkg.instantiate()' # Install Trixi's dependencies
+julia --project=@. -e 'import Pkg; Pkg.instantiate()' # Install Trixi's dependencies
 julia -e 'import Pkg; Pkg.add("Trixi2Vtk"); Pkg.add("Trixi2Img")' # Install postprocessing tools
 ```
 If you installed Trixi this way, you always have to start Julia with the `--project`
 flag set to your local Trixi clone, e.g.,
 ```bash
-julia --project=.
+julia --project=@.
 ```
 Further details can be found in the [documentation](#documentation).
 
@@ -87,7 +88,7 @@ julia> using Trixi
 ```
 Then start a simulation by executing
 ```julia
-julia> Trixi.run(default_example())
+julia> trixi_include(default_example())
 ```
 To visualize the results, load the package Trixi2Img
 ```julia
@@ -103,21 +104,23 @@ that can be opened with any image viewer:
   <img width="300px" src="docs/src/assets/solution_000040_scalar_resized.png">
 </p>
 
-The method `Trixi.run(...)` expects a single string argument with the path to a
-Trixi parameter file. To quickly see Trixi in action, `default_example()`
-returns the path to an example parameter file with a short, two-dimensional
-problem setup. A list of all example parameter files packaged with Trixi can be
+The method `trixi_include(...)` expects a single string argument with the path to a
+Trixi elixir, i.e.. a text file containing Julia code necessary to set up and run a
+simulation. To quickly see Trixi in action, `default_example()`
+returns the path to an example elixir with a short, two-dimensional
+problem setup. A list of all example elixirs packaged with Trixi can be
 obtained by running `get_examples()`. Alternatively, you can also browse the
-[`examples/`](examples/) subdirectory. If you want to
-modify one of the parameter files to set up your own simulation, download it to
-your machine, edit the configuration, and pass the file path to `Trixi.run(...)`.
+[`examples/`](examples/) subdirectory.
+If you want to modify one of the elixirs to set up your own simulation,
+download it to your machine, edit the configuration, and pass the file path to
+`trixi_include(...)`.
 
 *Note on performance:* Julia uses just-in-time compilation to transform its
 source code to native, optimized machine code at the *time of execution* and
 caches the compiled methods for further use. That means that the first execution
 of a Julia method is typically slow, with subsequent runs being much faster. For
-instance, in the example above the first execution of `Trixi.run` takes about 15
-seconds, while subsequent runs require less than 50 *milli*seconds.
+instance, in the example above the first execution of `trixi_include` takes about
+20 seconds, while subsequent runs require less than 50 *milli*seconds.
 
 
 ## Documentation
diff --git a/docs/src/development.md b/docs/src/development.md
index e78f15046e..8c9f2e1d93 100644
--- a/docs/src/development.md
+++ b/docs/src/development.md
@@ -16,7 +16,7 @@ which destroys any potential benefits from caching. However, restarting
 Julia can be avoided by using the [Revise.jl](https://github.com/timholy/Revise.jl)
 package, which tracks changed files and re-loads them automatically. Therefore,
 it is *highly recommended* to first install Revise with the following command in Julia:
-To enter the packe REPL mode, press `]` in the standard Julia REPL mode. Then, execute
+To enter the package REPL mode, press `]` in the standard Julia REPL mode. Then, execute
 ```julia
 (@v1.5) pkg> add Revise
 ```
@@ -47,7 +47,7 @@ julia> using Revise; using Trixi
 ```
 You can run a simulation by executing
 ```julia
-julia> Trixi.run("examples/2d/parameters_advection_basic.toml")
+julia> trixi_include(default_example())
 ```
 Together, all of these commands can take some time, roughly half a minute on a
 modern workstation. Most of the time is spent on compilation of Julia code etc.
@@ -77,7 +77,7 @@ if Trixi is not installed in the global environment. The same procedure also
 applies should you opt to install the postprocessing tools
 [Trixi2Vtk](https://github.com/trixi-framework/Trixi2Vtk.jl) and
 [Trixi2Img](https://github.com/trixi-framework/Trixi2Img.jl) manually such that
-you can modify their implemenations.
+you can modify their implementations.
 
 
 ### Pitfalls when using Revise
@@ -153,7 +153,7 @@ which will set the project path, load Revise (if installed), and import Trixi:
 ```bash
 julia> include("utils/juno.jl")
 ```
-Afterwards, you can start Trixi in the usual way by calling the `Trixi.run` method.
+Afterwards, you can start Trixi in the usual way by calling the `trixi_include` method.
 
 ### Vim or Emacs
 Vim and Emacs are both very popular editors that work great with Julia. One
@@ -246,8 +246,7 @@ You can also make it more detailed by benchmarking only, e.g., the calculation o
 6. Set the correct version number in the badge "GitHub commits since tagged version"
    in README.md.
    The badge will only show up correctly if TagBot has released a new version. This will
-   be done automatically over night. If you don't want to wait, trigger the GitHub Action
-   TagBot manually.
+   be done automatically.
 7. When a new version of Trixi was released, check whether the `[compat]` entries
    in `test/Project.toml` in Trixi2Vtk/Trixi2Img should be updated.
    When a new version of Trixi2Vtk/Trixi2Img was released, check whether the `[compat]`
diff --git a/docs/src/github-git.md b/docs/src/github-git.md
index bfa5d3cd91..70ee3acef1 100644
--- a/docs/src/github-git.md
+++ b/docs/src/github-git.md
@@ -4,7 +4,7 @@ This page contains information on how to use GitHub and Git when developing Trix
 
 ## Development workflow
 
-For adding modifcations to Trixi, we generally follow these steps:
+For adding modifications to Trixi, we generally follow these steps:
 
 ### Create an issue (optional)
 In many cases it makes sense to start by creating an issue on GitHub. For
@@ -42,7 +42,8 @@ git push -u myfork
     Immediately creating a PR for your branch has the benefit that all
     code discussions can now be held directly next to the corresponding code. Also,
     the PR allows to easily compare your branch to the upstream branch
-    (usually `master`) to see what you have changed.
+    (usually `master`) to see what you have changed. Moreover, tests will run
+    automatically.
 
 ### Make changes
 With a branch and PR in place, you can now write your code and commit
@@ -86,13 +87,13 @@ review. That is, you should
 
   * merge the current `master` to your branch
   * run tests if available, but at least ensure that you did not accidentally
-    change the results for one of the existing parameter files
+    change the results for one of the existing example elixirs
   * properly comment your code
   * delete old/unused code, especially commented lines (unless they contain
     helpful code, in which case you should add a comment on why you keep this
     around)
   * remove debug statements
-  * add a `parameters_xxx.toml` that uses your feature (only relevant for new
+  * add a `elixir_xxx.jl` that uses your feature (only relevant for new
     features)
   * make sure your code formatting adheres to the [Style guide](@ref)
 
@@ -116,10 +117,12 @@ we just try to keep Trixi as accessible and easy to use for everyone.
 
 ### Merge branch
 Once your branch is reviewed and declared ready for merging by the reviewer,
-make sure that all the latest changes have been pushed. Then, go
+make sure that all the latest changes have been pushed. Then, one of the
+developers will merge your PR. If you are one of the developers, you can also go
 to the pull request page on GitHub and and click on **Merge pull request**.
 Voilá, you are done! Your branch will have been merged to
-`master` and the source branch will have been deleted in the GitHub repository (if you are not working in your own fork).
+`master` and the source branch will have been deleted in the GitHub repository
+(if you are not working in your own fork).
 
 ### Update your working copy
 Once you have merged your branch by accepting the PR on GitHub, you
@@ -156,7 +159,7 @@ git reset HEAD~
 ```
 This only works if you have not yet pushed your branch to the GitHub repository.
 In this case, please talk to one of the core developers on how to proceed.
-Especially when you accidentally commited a large file (image, or video), please
+Especially when you accidentally committed a large file (image, or video), please
 let us know as fast as possible, since the effort to fix the repository grows
 considerably over time.
 
@@ -164,7 +167,7 @@ considerably over time.
 If a large file was accidentally committed **and pushed** to the Trixi
 repository, please talk to one of the core developers as soon as possible so that they can fix it.
 
-!!! danger
+!!! danger "Large files"
     You should never try to fix this yourself, as it potentially
     disrupts/destroys the work of others!
 
diff --git a/docs/src/index.md b/docs/src/index.md
index a142c225ad..c4cce01030 100644
--- a/docs/src/index.md
+++ b/docs/src/index.md
@@ -8,13 +8,16 @@ focused on being easy to use for new or inexperienced users, including the
 installation and postprocessing procedures. Its features include:
 
 * Hierarchical quadtree/octree grid with adaptive mesh refinement
-* Native support for 2D and 3D simulations
+* Native support for 1D, 2D, and 3D simulations
 * High-order accuracy in space in time
 * Nodal discontinuous Galerkin spectral element methods
   * Kinetic energy-preserving and entropy-stable split forms
   * Entropy-stable shock capturing
   * Positivity-preserving limiting
-* Explicit low-storage Runge-Kutta time integration
+* Compatible with the [SciML ecosystem for ordinary differential equations](https://diffeq.sciml.ai/latest/)
+  * [Explicit low-storage Runge-Kutta time integration](https://diffeq.sciml.ai/latest/solvers/ode_solve/#Low-Storage-Methods)
+  * [Strong stability preserving methods](https://diffeq.sciml.ai/latest/solvers/ode_solve/#Explicit-Strong-Stability-Preserving-Runge-Kutta-Methods-for-Hyperbolic-PDEs-(Conservation-Laws))
+  * CFL-based and error-based time step control
 * Square/cubic domains with periodic and weakly-enforced boundary conditions
 * Multiple governing equations:
   * Compressible Euler equations
@@ -24,7 +27,8 @@ installation and postprocessing procedures. Its features include:
 * Multi-physics simulations
   * [Self-gravitating gas dynamics](https://github.com/trixi-framework/paper-self-gravitating-gas-dynamics)
 * Shared-memory parallelization via multithreading
-* Visualization of results with Julia-only tools ([Trixi2Img](https://github.com/trixi-framework/Trixi2Img.jl)) or ParaView/VisIt ([Trixi2Vtk](https://github.com/trixi-framework/Trixi2Vtk.jl))
+* Visualization of results with Julia-only tools ([Trixi2Img](https://github.com/trixi-framework/Trixi2Img.jl))
+  or ParaView/VisIt ([Trixi2Vtk](https://github.com/trixi-framework/Trixi2Vtk.jl))
 
 
 ## Installation
@@ -65,7 +69,7 @@ If you plan on editing Trixi itself, you have two options: installing it as a
    ```bash
    git clone git@github.com:trixi-framework/Trixi.jl.git
    cd Trixi.jl
-   julia --project=. -e 'import Pkg; Pkg.instantiate()' # Install Trixi's dependencies
+   julia --project=@. -e 'import Pkg; Pkg.instantiate()' # Install Trixi's dependencies
    ```
    The last line can also be used to *update* the dependencies if they have changed
    since you first installed Trixi.
@@ -73,12 +77,11 @@ If you plan on editing Trixi itself, you have two options: installing it as a
    If you installed Trixi this way, you always have to start Julia with the `--project`
    flag set to your local Trixi clone, e.g.,
    ```bash
-   julia --project=.
+   julia --project=@.
    ```
 
-Either way, since the
-postprocessing tools typically do not need to be modified, it is recommended to
-install them as normal packages by executing
+Either way, since the postprocessing tools typically do not need to be modified,
+it is recommended to install them as normal packages by executing
 ```julia
 julia> import Pkg
 
@@ -109,7 +112,7 @@ julia> using Trixi
 ```
 Then start a simulation by executing
 ```julia
-julia> Trixi.run(default_example())
+julia> trixi_include(default_example())
 ```
 To visualize the results, load the package Trixi2Img
 ```julia
@@ -124,16 +127,19 @@ that can be opened with any image viewer:
 
 !["solution_000040_scalar_resized"](assets/solution_000040_scalar_resized.png)
 
-The method `Trixi.run(...)` expects a single string argument with the path to a
-Trixi parameter file. To quickly see Trixi in action, `default_example()`
-returns the path to an example parameter file with a short, two-dimensional
-problem setup. A list of all example parameter files packaged with Trixi can be
+The method `trixi_include(...)` expects a single string argument with the path to a
+Trixi elixir, i.e.. a text file containing Julia code necessary to set up and run a
+simulation. To quickly see Trixi in action, `default_example()`
+returns the path to an example elixir with a short, two-dimensional
+problem setup. A list of all example elixirs packaged with Trixi can be
 obtained by running `get_examples()`. Alternatively, you can also browse the
-[`examples/`](https://github.com/trixi-framework/Trixi.jl/examples/) subdirectory. If you want to
-modify one of the parameter files to set up your own simulation, download it to
-your machine, edit the configuration, and pass the file path to `Trixi.run(...)`.
+[`examples/`](https://github.com/trixi-framework/Trixi.jl/examples/) subdirectory.
+If you want to modify one of the elixirs to set up your own simulation,
+download it to your machine, edit the configuration, and pass the file path to
+`trixi_include(...)`.
 
 ### Example: Running a simulation with Trixi
+<!-- TODO: Taal docs, create new version of this asciicast -->
 ```@raw html
   <script id="asciicast-356942"
           src="https://asciinema.org/a/356942.js"
@@ -145,25 +151,25 @@ your machine, edit the configuration, and pass the file path to `Trixi.run(...)`
 source code to native, optimized machine code at the *time of execution* and
 caches the compiled methods for further use. That means that the first execution
 of a Julia method is typically slow, with subsequent runs being much faster. For
-instance, in the example above the first execution of `Trixi.run` takes about 15
-seconds, while subsequent runs require less than 50 *milli*seconds.
+instance, in the example above the first execution of `trixi_include` takes about
+20 seconds, while subsequent runs require less than 50 *milli*seconds.
 
 
 ### Performing a convergence analysis
 To automatically determine the experimental order of convergence (EOC) for a
 given setup, execute
 ```julia
-Trixi.convtest("examples/2d/parameters_advection_basic.toml", 4)
+julia> convergence_test(default_example(), 4)
 ```
-This will run a convergence test with the parameters file `examples/2d/parameters_advection_basic.toml`,
+This will run a convergence test with the elixir `default_example()`,
 using four iterations with different initial refinement levels. The initial
 iteration will use the parameters file unchanged, while for each subsequent
 iteration the `initial_refinement_level` parameter is incremented by one.
-Finally, the measured ``L^2`` and ``L^\infty`` errors and the determined EOCs
+Finally, the measured ``l^2`` and ``l^\infty`` errors and the determined EOCs
 will be displayed like this:
 ```
 [...]
-L2
+l2
 scalar
 error     EOC
 9.14e-06  -
@@ -173,7 +179,7 @@ error     EOC
 
 mean      4.00
 --------------------------------------------------------------------------------
-Linf
+linf
 scalar
 error     EOC
 6.44e-05  -
@@ -187,11 +193,11 @@ mean      3.99
 
 An example with multiple variables looks like this:
 ```julia
-julia> Trixi.convtest("examples/2d/parameters_euler_source_terms.toml", 3)
+julia> convergence_test(joinpath(examples_dir(), "2d", "elixir_euler_source_terms.jl"), 3)
 ```
 ```
 [...]
-L2
+l2
 rho                 rho_v1              rho_v2              rho_e
 error     EOC       error     EOC       error     EOC       error     EOC
 8.52e-07  -         1.24e-06  -         1.24e-06  -         4.28e-06  -
@@ -200,7 +206,7 @@ error     EOC       error     EOC       error     EOC       error     EOC
 
 mean      3.81      mean      3.92      mean      3.92      mean      3.90
 --------------------------------------------------------------------------------
-Linf
+linf
 rho                 rho_v1              rho_v2              rho_e
 error     EOC       error     EOC       error     EOC       error     EOC
 8.36e-06  -         1.03e-05  -         1.03e-05  -         4.50e-05  -
diff --git a/docs/src/parallelization.md b/docs/src/parallelization.md
index 3909cd2c6b..8f82ee9db1 100644
--- a/docs/src/parallelization.md
+++ b/docs/src/parallelization.md
@@ -17,11 +17,16 @@ want to use by either setting the environment variable `JULIA_NUM_THREADS` or by
 providing the `-t/--threads` command line argument. For example, to start Julia
 with four threads, start Julia with
 ```bash
-julia -t 4
+julia --threads=4
 ```
 If both the environment variable and the command line argument are specified at
 the same time, the latter takes precedence.
 
+!!! warning
+    Not everything is parallelized yet and there are likely opportunities to
+    improve scalability. Multi-threading isn't considered part of the public
+    API of Trixi yet.
+
 
 ## Distributed computing with MPI
 In addition to the shared memory parallelization with multi-threading, Trixi.jl
@@ -34,6 +39,10 @@ running MPI programs on a cluster or supercomputer
 ([see the MPI.jl docs](https://juliaparallel.github.io/MPI.jl/stable/configuration/)
 to find out how to select the employed MPI library).
 
+!!! warning "Work in progress"
+    MPI-based parallelization is work in progress and not finished yet. Nothing
+    related to MPI is part of the official API of Trixi yet.
+
 To start Trixi in parallel with MPI, there are three options:
 
 1. **Run from the REPL with `mpiexec()`:** You can start a parallel execution directly from the
@@ -42,7 +51,7 @@ To start Trixi in parallel with MPI, there are three options:
    julia> using MPI
 
    julia> mpiexec() do cmd
-            run(`$cmd -n 3 $(Base.julia_cmd()) --project=. -e 'using Trixi; Trixi.run("examples/2d/parameters.toml")'`)
+            run(`$cmd -n 3 $(Base.julia_cmd()) --project=@. -e 'using Trixi; trixi_include("examples/2d/parameters.toml")'`)
           end
    ```
    The parameter `-n 3` specifies that Trixi should run with three processes (or
@@ -51,7 +60,7 @@ To start Trixi in parallel with MPI, there are three options:
    ensures that Julia is executed in parallel with the same optimization level
    etc. as you used for the REPL; if this is unnecessary or undesired, you can
    also just use `julia`.  Further, if you are not running Trixi from a local
-   clone but have installed it as a package, you need to omit the `--project=.`.
+   clone but have installed it as a package, you need to omit the `--project=@.`.
 2. **Run from the command line with `mpiexecjl`:** Alternatively, you can
    use the `mpiexecjl` script provided by MPI.jl, which allows you to start
    Trixi in parallel directly from the command line. As a preparation, you need to
@@ -64,7 +73,7 @@ To start Trixi in parallel with MPI, there are three options:
    Then, to execute Trixi in parallel, execute the following command from your
    command line:
    ```bash
-   mpiexecjl -n 3 julia --project=. -e 'using Trixi; Trixi.run("examples/2d/parameters.toml")'
+   mpiexecjl -n 3 julia --project=@. -e 'using Trixi; trixi_include("examples/2d/parameters.toml")'
    ```
 3. **Run interactively with `tmpi` (Linux/MacOS only):** If you are on a
    Linux/macOS system, you have a third option which lets you run Julia in
@@ -86,7 +95,7 @@ To start Trixi in parallel with MPI, there are three options:
    Finally, you can start and control multiple Julia REPLs simultaneously by
    running
    ```bash
-   tmpi 3 julia --project=.
+   tmpi 3 julia --project=@.
    ```
    This will start Julia inside `tmux` three times and multiplexes all commands
    you enter in one REPL to all other REPLs (try for yourself to understand what
diff --git a/docs/src/time_integration.md b/docs/src/time_integration.md
index a61ee48733..fb4e3ba486 100644
--- a/docs/src/time_integration.md
+++ b/docs/src/time_integration.md
@@ -7,14 +7,6 @@ Interesting classes of time integration schemes are
 - [Explicit low-storage Runge-Kutta methods](https://diffeq.sciml.ai/latest/solvers/ode_solve/#Low-Storage-Methods)
 - [Strong stability preserving methods](https://diffeq.sciml.ai/latest/solvers/ode_solve/#Explicit-Strong-Stability-Preserving-Runge-Kutta-Methods-for-Hyperbolic-PDEs-(Conservation-Laws))
 
-!!! note
-
-  If you use explicit Runge-Kutta methods from [OrdinaryDiffEq.jl](https://github.com/SciML/OrdinaryDiffEq.jl),
-  the total number of `rhs!` calls can be (slightly) bigger than the number of steps times the number
-  of stages, e.g. to allow for interpolation (dense output), root-finding for continuous callbacks,
-  and error-based time step control. In general, you often should not need to worry about this if you
-  use Trixi.
-
 Some common options for `solve` from [OrdinaryDiffEq.jl](https://github.com/SciML/OrdinaryDiffEq.jl)
 are the following. Further documentation can be found in the
 [SciML docs](https://diffeq.sciml.ai/v6.8/basics/common_solver_opts/).
@@ -25,3 +17,13 @@ are the following. Further documentation can be found in the
   (try to) save the numerical solution after every time step in RAM (until you run
   out of memory or start to swap).
 - You can set the maximal number of time steps via `maxiters=...`.
+- SSP methods and 2N low-storage methods from OrdinaryDiffEq.jl support
+  `stage_limiter!`s and `step_limiter!`s, e.g. `PositivityPreservingLimiterZhangShu`
+  from Trixi.
+
+!!! note "Number of `rhs!` calls"
+    If you use explicit Runge-Kutta methods from [OrdinaryDiffEq.jl](https://github.com/SciML/OrdinaryDiffEq.jl),
+    the total number of `rhs!` calls can be (slightly) bigger than the number of steps times the number
+    of stages, e.g. to allow for interpolation (dense output), root-finding for continuous callbacks,
+    and error-based time step control. In general, you often should not need to worry about this if you
+    use Trixi.
diff --git a/docs/src/visualization.md b/docs/src/visualization.md
index 9f940161ca..7125bbecd0 100644
--- a/docs/src/visualization.md
+++ b/docs/src/visualization.md
@@ -7,7 +7,8 @@ and
 
 ## Trixi2Vtk
 Trixi2Vtk converts Trixi's `.h5` output files to VTK files, which can be read
-by [ParaView](https://www.paraview.org), [VisIt](https://visit.llnl.gov), and other visualization tools. It
+by [ParaView](https://www.paraview.org), [VisIt](https://visit.llnl.gov),
+and other visualization tools. It
 automatically interpolates solution data from the original quadrature node
 locations to equidistant *visualization nodes* at a higher resolution, to make
 up for the loss of accuracy from going from a high-order polynomial
@@ -21,7 +22,7 @@ To process an HDF5 file generated by Trixi.jl, execute
 ```julia
 julia> trixi2vtk(joinpath("out", "solution_000000.h5"), output_directory="out")
 ```
-This will create two unstructured VTK files in the `out/` subdirectory that can
+This will create two unstructured VTK files in the `out` subdirectory that can
 be opened with ParaView or VisIt: `solution_000000.vtu` contains the
 discontinuous Galerkin solution data while `solution_000000_celldata.vtu` holds
 any cell-based values such as the current AMR indicator or the cell refinement
diff --git a/src/Trixi.jl b/src/Trixi.jl
index f24d3e2dc9..967d2cbe5e 100644
--- a/src/Trixi.jl
+++ b/src/Trixi.jl
@@ -18,7 +18,7 @@ using LinearAlgebra: dot
 using Pkg.TOML: parsefile, parse
 using Printf: @printf, @sprintf, println
 using Profile: clear_malloc_data # TODO: Taal, remove this dependency
-using Random: seed!
+using Random: seed! # TODO: Taal, remove this dependency
 
 import DiffEqBase: ODEProblem, ODESolution, get_du, u_modified!, set_proposed_dt!, terminate!
 using DiffEqCallbacks: CallbackSet, DiscreteCallback
diff --git a/src/equations/1d/linear_scalar_advection.jl b/src/equations/1d/linear_scalar_advection.jl
index b0da1c5c16..0e4a7ddaba 100644
--- a/src/equations/1d/linear_scalar_advection.jl
+++ b/src/equations/1d/linear_scalar_advection.jl
@@ -90,7 +90,7 @@ end
 """
     initial_condition_gauss(x, t, equations::LinearScalarAdvectionEquation1D)
 
-A Gaussien pulse used together with
+A Gaussian pulse used together with
 [`boundary_condition_gauss`](@ref).
 """
 function initial_condition_gauss(x, t, equation::LinearScalarAdvectionEquation1D)
diff --git a/src/equations/2d/linear_scalar_advection.jl b/src/equations/2d/linear_scalar_advection.jl
index 7be2021416..093e3eff60 100644
--- a/src/equations/2d/linear_scalar_advection.jl
+++ b/src/equations/2d/linear_scalar_advection.jl
@@ -76,7 +76,7 @@ end
 """
     initial_condition_gauss(x, t, equation::LinearScalarAdvectionEquation2D)
 
-A Gaussien pulse used together with
+A Gaussian pulse used together with
 [`boundary_condition_gauss`](@ref).
 """
 function initial_condition_gauss(x, t, equation::LinearScalarAdvectionEquation2D)
diff --git a/src/equations/3d/linear_scalar_advection.jl b/src/equations/3d/linear_scalar_advection.jl
index 993958ad8b..84abba2b4b 100644
--- a/src/equations/3d/linear_scalar_advection.jl
+++ b/src/equations/3d/linear_scalar_advection.jl
@@ -69,7 +69,7 @@ end
 """
     initial_condition_gauss(x, t, equations::LinearScalarAdvectionEquation1D)
 
-A Gaussien pulse.
+A Gaussian pulse.
 """
 function initial_condition_gauss(x, t, equation::LinearScalarAdvectionEquation3D)
   # Store translated coordinate for easy use of exact solution
diff --git a/src/run.jl b/src/run.jl
index dd489477ac..ef1212975f 100644
--- a/src/run.jl
+++ b/src/run.jl
@@ -42,7 +42,7 @@ function find_assignment(expr, destination)
 end
 
 
-# Note: Wa can't call the method below `Trixi.include` since that is created automatically
+# Note: We can't call the method below `Trixi.include` since that is created automatically
 # inside `module Trixi` to `include` source files and evaluate them within the global scope
 # of `Trixi`. However, users will want to evaluate in the global scope of `Main` or something
 # similar to manage dependencies on their own.
@@ -58,8 +58,9 @@ providing examples with sensible default values for users.
 # Examples
 
 ```jldoctest
-julia> trixi_include(default_example(), tspan=(0.0, 0.1))
-...
+julia> trixi_include(@__MODULE__, default_example(), tspan=(0.0, 0.1))
+[...]
+
 julia> sol.t[end]
 0.1
 ```