categories.toml

# This is where the categories available on crates.io are defined. To propose
# a change to the categories, send a pull request with your change made to this
# file.
#
# For help with TOML, see: https://github.com/toml-lang/toml
#
# Format:
#
# ```toml
# [slug]
# name = "Display name"
# description = "Give an idea of the crates that belong in this category."
#
#  [slug.categories.subcategory-slug]
#  name = "Subcategory display name, not including parent category display name"
#  description = "Give an idea of the crates that belong in this subcategory."
# ```
#
# Notes:
# - Slugs are the primary identifier. If you make a change to a category's slug,
#   crates that have been published with that slug will need to be updated to
#   use the new slug in order to stay in that category. If you only change
#   names and descriptions, those attributes CAN be updated without affecting
#   crates in that category.
# - Slugs are used in the path of URLs, so they should not contain spaces, `/`,
#   `@`, `:`, or `.`. They should be all lowercase.
#

[algorithms]
name = "Algorithms"
description = """
Rust implementations of core algorithms such as hashing, sorting, \
searching, and more.\
"""

[api-bindings]
name = "API bindings"
description = """
Idiomatic wrappers of specific APIs for convenient access from \
Rust. Includes HTTP API wrappers as well. Non-idiomatic or unsafe \
bindings can be found in External FFI bindings.\
"""

[asynchronous]
name = "Asynchronous"
description = """
Crates to help you deal with events independently of the main program \
flow, using techniques like futures, promises, waiting, or eventing.\
"""

[authentication]
name = "Authentication"
description = """
Crates to help with the process of confirming identities.\
"""

[caching]
name = "Caching"
description = """
Crates to store the results of previous computations in order to reuse \
the results.\
"""

[command-line-interface]
name = "Command-line interface"
description = """
Crates to help create command line interfaces, such as argument \
parsers, line-editing, or output coloring and formatting.\
"""

[command-line-utilities]
name = "Command line utilities"
description = """
Applications to run at the command line.\
"""

[compression]
name = "Compression"
description = """
Algorithms for making data smaller.\
"""

[config]
name = "Configuration"
description = """
Crates to facilitate configuration management for applications.\
"""

[concurrency]
name = "Concurrency"
description = """
Crates for implementing concurrent and parallel computation.\
"""

[cryptography]
name = "Cryptography"
description = """
Algorithms intended for securing data.\
"""

[cryptography.categories.cryptocurrencies]
name = "Cryptocurrencies"
description = """
Crates for digital currencies, wallets, and distributed ledgers.\
"""

[database]
name = "Database interfaces"
description = """
Crates to interface with database management systems.\
"""

[database-implementations]
name = "Database implementations"
description = """
Databases allow clients to store and query large amounts of data in an \
efficient manner. This category is for database management systems \
implemented in Rust.\
"""

[data-structures]
name = "Data structures"
description = """
Rust implementations of particular ways of organizing data suited for \
specific purposes.\
"""

[date-and-time]
name = "Date and time"
description = """
Crates to manage the inherent complexity of dealing with the fourth \
dimension.\
"""

[development-tools]
name = "Development tools"
description = """
Crates that provide developer-facing features such as testing, debugging, \
linting, performance profiling, autocompletion, formatting, and more.\
"""

[development-tools.categories.build-utils]
name = "Build Utils"
description = """
Utilities for build scripts and other build time steps.\
"""

[development-tools.categories.cargo-plugins]
name = "Cargo plugins"
description = """
Subcommands that extend the capabilities of Cargo.\
"""

[development-tools.categories.debugging]
name = "Debugging"
description = """
Crates to help you figure out what is going on with your code such as \
logging, tracing, or assertions.\
"""

[development-tools.categories.ffi]
name = "FFI"
description = """
Crates to help you better interface with other languages. This \
includes binding generators and helpful language constructs.\
"""

[development-tools.categories.procedural-macro-helpers]
name = "Procedural macro helpers"
description = """
Crates to help you write procedural macros in Rust.
"""

[development-tools.categories.profiling]
name = "Profiling"
description = """
Crates to help you figure out the performance of your code.\
"""

[development-tools.categories.testing]
name = "Testing"
description = """
Crates to help you verify the correctness of your code.\
"""

[email]
name = "Email"
description = """
Crates to help with Sending, receiving, formatting, and parsing email.\
"""

[embedded]
name = "Embedded development"
description = """
Crates that are primarily useful on embedded devices or \
without an operating system.
"""

[emulators]
name = "Emulators"
description = """
Emulators allow one computer to behave like another, often to allow \
running software that is not natively available on the host \
computer. Video game systems are commonly emulated.\
"""

[encoding]
name = "Encoding"
description = """
Encoding and/or decoding data from one data format to another.\
"""

[external-ffi-bindings]
name = "External FFI bindings"
description = """
Direct Rust FFI bindings to libraries written in other languages; \
often denoted by a -sys suffix. Safe and idiomatic wrappers are in \
the API bindings category.
"""

[filesystem]
name = "Filesystem"
description = """
Crates for dealing with files and filesystems.\
"""

[game-engines]
name = "Game engines"
description = """
For crates that try to provide a \"one-stop-shop\" for \
all of your game development needs.\
"""

[game-development]
name = "Game development"
description = """
For crates that focus on some individual part of accelerating \
the development of games.\
"""

[games]
name = "Games"
description = """
Applications for fun and entertainment. If Rust the video game were \
implemented in Rust the programming language, it would belong in this \
category. Libraries to help create video games are in the \
Game engines category.\
"""

[graphics]
name = "Graphics"
description = """
Crates for graphics libraries and applications, including raster and vector \
graphics primitives such as geometry, curves, and color.\
"""

[gui]
name = "GUI"
description = """
Crates to help you create a graphical user interface.\
"""

[hardware-support]
name = "Hardware support"
description = """
Crates to interface with specific CPU or other hardware features.\
"""

[internationalization]
name = "Internationalization (i18n)"
description = """
Crates to help develop software capable of adapting to various \
languages and regions.\
"""

[localization]
name = "Localization (L10n)"
description = """
Crates to help adapting internationalized software to specific \
languages and regions.\
"""

[mathematics]
name = "Mathematics"
description = """
Crates with a mathematical aspect.
"""

[memory-management]
name = "Memory management"
description = """
Crates to help with allocation, memory mapping, garbage collection, \
reference counting, or interfaces to foreign memory managers.\
"""

[multimedia]
name = "Multimedia"
description = """
Crates that provide audio, video, and image processing or rendering \
engines.\
"""

[multimedia.categories.audio]
name = "Audio"
description = """
Crates that record, output, or process audio.
"""

[multimedia.categories.video]
name = "Video"
description = """
Crates that record, output, or process video.
"""

[multimedia.categories.images]
name = "Images"
description = """
Crates that process or build images.
"""

[multimedia.categories.encoding]
name = "Encoding"
description = """
Crates that encode or decode binary data in multimedia formats.
"""

[network-programming]
name = "Network programming"
description = """
Crates dealing with higher-level network protocols such as FTP, HTTP, \
or SSH, or lower-level network protocols such as TCP or UDP.\
"""

[no-std]
name = "No standard library"
description = """
Crates that are able to function without the Rust standard library.
"""

[os]
name = "Operating systems"
description = """
Bindings to operating system-specific APIs.\
"""

[os.categories.macos-apis]
name = "mac OS APIs"
description = """
Bindings to mac OS-specific APIs.\
"""

[os.categories.unix-apis]
name = "Unix APIs"
description = """
Bindings to Unix-specific APIs.\
"""

[os.categories.windows-apis]
name = "Windows APIs"
description = """
Bindings to Windows-specific APIs.\
"""

[parser-implementations]
name = "Parser implementations"
description = """
Parsers implemented for particular formats or languages.\
"""

[parsing]
name = "Parsing tools"
description = """
Crates to help create parsers of binary and text \
formats. Format-specific parsers belong in other, more specific \
categories.\
"""

[rendering]
name = "Rendering"
description = """
Real-time or offline rendering of 2D or 3D graphics, \
usually with the help of a graphics card.\
"""

[rendering.categories.engine]
name = "Rendering engine"
description = """
High-level solutions for rendering on the screen.\
"""

[rendering.categories.graphics-api]
name = "Graphics APIs"
description = """
Crates that provide direct access to the hardware's or the operating \
system's rendering capabilities.\
"""

[rendering.categories.data-formats]
name = "Data formats"
description = """
Loading and parsing of data formats related to 2D or 3D rendering, like \
3D models or animation sheets.\
"""

[rust-patterns]
name = "Rust patterns"
description = """
Shared solutions for particular situations specific to programming in \
Rust.\
"""

[science]
name = "Science"
description = """
Crates related to solving problems involving physics, chemistry, \
biology, machine learning, geoscience, and other scientific fields.\
"""

[science.categories.robotics]
name = "Robotics"
description = """
Crates related to robotics.\
"""

[simulation]
name = "Simulation"
description = """
Crates used to model or construct models for some activity, e.g. to.\
simulate a networking protocol.\
"""

[template-engine]
name = "Template engine"
description = """
Crates designed to combine templates with data to produce result \
documents, usually with an emphasis on processing text.\
"""

[text-editors]
name = "Text editors"
description = """
Applications for editing text.\
"""

[text-processing]
name = "Text processing"
description = """
Crates to deal with the complexities of human language when expressed \
in textual form.\
"""

[value-formatting]
name = "Value formatting"
description = """
Crates to allow an application to format values for display to a user, \
potentially adapting the display to various languages and regions.\
"""

[visualization]
name = "Visualization"
description = """
Ways to view data, such as plotting or graphing.\
"""

[wasm]
name = "WebAssembly"
description = """
Crates for use when targeting WebAssembly, or for manipulating WebAssembly.\
"""

[web-programming]
name = "Web programming"
description = """
Crates to create applications for the web.\
"""

[web-programming.categories.http-client]
name = "HTTP client"
description = """
Crates to make HTTP network requests.\
"""

[web-programming.categories.http-server]
name = "HTTP server"
description = """
Crates to serve data over HTTP.\
"""

[web-programming.categories.websocket]
name = "WebSocket"
description = """
Crates to communicate over the WebSocket protocol.\
"""