The file renaming utilities (renameutils for short) are a set of programs designed to make renaming of files faster and less cumbersome. The file renaming utilities consists of five programs: qmv, qcp, imv, icp, and deurlname.

Starship is a shell prompt that is fast and configurable, and works on most common shells. It shows information from various sources in a way easy to grasp at a glance, including but not limited to: the hostname/username/cwd trio, git, project language and runtime.

Note: Users must have a nerd font installed and enabled in their terminal.

This package provides syntax highlighting for Zsh. It enables highlighting of commands whilst they are typed at a Zsh prompt into an interactive terminal. This helps in reviewing commands before running them, particularly in catching syntax errors.

pay-respects provides a shell helper to suggest correction for mistyped commands, with guix locate integration and an alias (default to f) to correct the previous command.

Most other fuzzy matchers sort based on the length of a match. fzy tries to find the result the user intended. It does this by favouring matches on consecutive letters and starts of words. This allows matching using acronyms or different parts of the path.

fzy is designed to be used both as an editor plugin and on the command line. Rather than clearing the screen, fzy displays its interface directly below the current cursor position, scrolling the screen if necessary.

This package provides a shell formatter. Supports POSIX Shell, Bash, and mksh.

This package provides an interactive setup for zsh preconfigured by the Grml project.

Liquidprompt is an adaptive prompt for Bash and Zsh that gives you a nicely displayed prompt with useful information when you need it. It does this with a powerful theming engine and a large array of data sources.

In order to use liquidprompt with Zsh, you should use the following snippet with Guix Home:

(service home-zsh-service-type
         (home-zsh-configuration
           (zshrc (list ;;...
                    ;; This loads liquidprompt
                    (mixed-text-file "liquidprompt"
                                     "[[ $- = *i* ]] && source " liquidprompt "/share/liquidprompt/liquidprompt")
                    ;; This loads the powerline theme available in liquidprompt
                    (mixed-text-file "powerline-theme"
                                     "source " liquidprompt "/share/liquidprompt/themes/powerline/powerline.theme"))))))

This projects aims at gathering/developing new completion scripts that are not available in Zsh yet. The scripts may be contributed to the Zsh project when stable enough.

The fzf-tab package replaces the default completion menu of the zsh shell with fzf, enabling fuzzy finding and multi-selection.

trash-cli is a command line utility for interacting with the FreeDesktop.org trash can used by GNOME, KDE, XFCE, and other common desktop environments. It can move files to the trash, and remove or list files that are already there.

SIMH is a highly portable, multi-system simulator. SIMH implements simulators for:

• Data General Nova, Eclipse.

• Digital Equipment Corporation PDP-1, PDP-4, PDP-7, PDP-8, PDP-9, PDP-10, PDP-11, PDP-15, VAX.

• GRI Corporation GRI-909, GRI-99.

• IBM 1401, 1620, 1130, 7090/7094, System 3.

• Interdata (Perkin-Elmer) 16b and 32b systems.

• Hewlett-Packard 2114, 2115, 2116, 2100, 21MX, 1000.

• Honeywell H316/H516.

• MITS Altair 8800, with both 8080 and Z80.

• Royal-Mcbee LGP-30, LGP-21.

• Scientific Data Systems SDS 940.

• SWTP 6800.

OpenFOAM provides a set of solvers and methods for tackling problems in the field of Computational Fluid Dynamics (CFD). It is written in C++. Governing equations such as the Navier-Stokes equations can be solved in integral form. Physical processes such as phase change, droplet transport and chemical reaction can be modelled. Numerical methods are included to deal with sharp gradients, such as those encountered in flows with shock waves and flows with gas/liquid interfaces. Large problems may be split into smaller, connected problems for efficient solution on parallel systems.

There are various file formats available for representing unstructured meshes and mesh data. The meshio package is able to read and write mesh files in many formats and to convert files from one format to another. Formats such as cgns, h5m, gmsh, xdmf and vtk are supported. The package provides command-line tools and a collection of Python modules for programmatic use.

This package provides vehicle models used in CommonRoad benchmarks. Varying abstraction levels are used ranging from kinematic single track models to multi-body models.

The Open Simulation Interface is a generic interface based on Google's protocol buffers for the environmental perception of automated driving functions in virtual scenarios.

The goal of pygmsh is to combine the power of Gmsh with the versatility of Python. The package generalises many of the methods and functions that comprise the Gmsh Python API. In this way the meshing of complex geometries using high-level abstractions is made possible. The package provides a Python library together with a command-line utility for mesh optimisation.

DOLFIN is a computational framework for finding numerical solutions to problems described by differential equations. Numerical models in DOLFIN are constructed using general families of finite elements. Data structures are provided for discretizing the governing system on a computational mesh. A compact syntax, similar to mathematical notation, is made available for defining function spaces and expressing variational forms. Interfaces to specialized matrix solvers are provided for solving the resultant linear systems.

fenics-dolfin is part of the FEniCS project. It is the C++ user interface to the FEniCS core components and external libraries.

SUMO is a traffic simulation package designed to handle large road networks and different modes of transportation -- including road vehicles, public transport and pedestrians. Included with SUMO is a wealth of supporting tools which automate core tasks for the creation, the execution and evaluation of traffic simulations, such as network import, route calculations, visualization and emission calculation. SUMO can be enhanced with custom models and provides various APIs to remotely control the simulation.

fenics is a computing platform for solving general classes of problems that involve differential equations. fenics facilitates access to efficient methods for dealing with ordinary differential equations (ODEs) and partial differential equations (PDEs). Systems of equations such as these are commonly encountered in areas of engineering, mathematics and the physical sciences. It is particularly well-suited to problems that can be solved using the Finite Element Method (FEM).

fenics is the top level of the set of packages that are developed within the FEniCS project. It provides the python user interface to the FEniCS core components and external libraries.

The FInite element Automatic Tabulator (FIAT) supports generation of arbitrary order instances of the Lagrange elements on lines, triangles, and tetrahedra. It is also capable of generating arbitrary order instances of Jacobi-type quadrature rules on the same element shapes. Further, H(div) and H(curl) conforming finite element spaces such as the families of Raviart-Thomas, Brezzi-Douglas-Marini and Nedelec are supported on triangles and tetrahedra. Upcoming versions will also support Hermite and nonconforming elements.

FIAT is part of the FEniCS Project.

This package provides methods to read, write, and visualize CommonRoad scenarios and planning problems. It can be used as a framework for implementing motion planning algorithms to solve CommonRoad Benchmarks and is the basis for other tools of the CommonRoad Framework.

Dijitso provides a core component of the FEniCS framework, namely the just-in-time compilation of C++ code that is generated from Python modules. It is called from within a C++ library, using ctypes to import the dynamic shared library directly.

As long as the compiled code can provide a simple factory function to a class implementing a predefined C++ interface, there is no limit to the complexity of that interface. Parallel support depends on the mpi4py interface.

The Open Simulation Interface is a generic interface based on Google's protocol buffers for the environmental perception of automated driving functions in virtual scenarios.