# unisonweb/unison

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/unisonweb-unison).**

6,487 stars · 296 forks · Haskell · other

## Links

- GitHub: https://github.com/unisonweb/unison
- Homepage: https://unison-lang.org
- awesome-repositories: https://awesome-repositories.com/repository/unisonweb-unison.md

## Topics

`hacktoberfest` `haskell` `programming-language` `unison` `unison-language`

## Tags

### Data & Databases

- [Content-Addressed Code Identifiers](https://awesome-repositories.com/f/data-databases/content-addressable-storage/content-addressed-code-identifiers.md) — Stores all definitions by their hash, eliminating dependency conflicts and enabling instant non-breaking renames across the entire codebase.
- [Release Snapshots](https://awesome-repositories.com/f/data-databases/backup-recovery/snapshot-tagging/release-snapshots.md) — Provides a mechanism to create immutable, versioned snapshots of a branch for use as stable library dependencies. ([source](https://unison-lang.org/docs/tooling/unison-share))
- [Content-Addressable Storage](https://awesome-repositories.com/f/data-databases/content-addressable-storage.md) — Stores all code as ASTs in a content-addressed database keyed by hash.
- [Literal](https://awesome-repositories.com/f/data-databases/data-collection-schemas/collection-initializers/literal.md) — Create a comma-separated sequence of values of the same type enclosed in square brackets. ([source](https://unison-lang.org/docs/language-reference/literals))
- [Remote Task Forkers](https://awesome-repositories.com/f/data-databases/data-processing-pipelines/data-processing/distributed-processing-frameworks/distributed-computing/remote-task-forkers.md) — Forks tasks to execute remotely and awaits their results using the Remote ability without external frameworks. ([source](https://unison-lang.org/docs))
- [Immutable Field Setters](https://awesome-repositories.com/f/data-databases/database-record-management/record-updates/immutable-field-setters.md) — Supports immutable field setting that returns a new record copy. ([source](https://unison-lang.org/docs/fundamentals/data-types/record-types))
- [Bytecode Shipping Platforms](https://awesome-repositories.com/f/data-databases/distributed-computing-platforms/bytecode-shipping-platforms.md) — Runs computations across remote nodes by shipping bytecode and syncing dependencies automatically.
- [Serialization-Free Persisters](https://awesome-repositories.com/f/data-databases/key-value-persistence-stores/serialization-free-persisters.md) — Provides native typed storage that persists values including functions without serialization code or schema definitions. ([source](https://unison-lang.org/docs/the-big-idea))
- [Expression Name Bindings](https://awesome-repositories.com/f/data-databases/named-parameter-bindings/expression-name-bindings.md) — Bind a name to an expression, optionally with parameters, so the expression can be referenced and reused elsewhere in code. ([source](https://unison-lang.org/docs/language-reference/term-definition))
- [Content-Addressed](https://awesome-repositories.com/f/data-databases/query-caching-strategies/compilation-caches/content-addressed.md) — Store parsed and type-checked definitions in an append-only codebase so no one ever re-parses or re-type-checks the same hash. ([source](https://unison-lang.org/docs/the-big-idea))
- [Automatic Dependency Sync](https://awesome-repositories.com/f/data-databases/remote-function-execution/automatic-dependency-sync.md) — Enables distributed execution by shipping bytecode and syncing dependencies automatically.
- [Field Accessor Functions](https://awesome-repositories.com/f/data-databases/structured-data-records/dynamic-record-generators/field-accessor-functions.md) — Generates accessor functions for retrieving named fields from record types. ([source](https://unison-lang.org/docs/fundamentals/data-types/record-types))
- [Functional Field Modifications](https://awesome-repositories.com/f/data-databases/structured-data-records/record-transformers/functional-field-modifications.md) — Provides immutable field modification by applying functions to record fields. ([source](https://unison-lang.org/docs/fundamentals/data-types/record-types))
- [Non-Breaking Name Rebindings](https://awesome-repositories.com/f/data-databases/view-definitions/view-renamers/non-breaking-name-rebindings.md) — Changes which hash a human-readable name points to while keeping all existing definitions runnable. ([source](https://unison-lang.org/docs/the-big-idea))
- [Branch State Rewinding](https://awesome-repositories.com/f/data-databases/model-state-restoration/checkpoint-based-state-restoration/codebase-snapshots/branch-state-rewinding.md) — Rewinds the current branch to a previous state using a specific hash or numbered position. ([source](https://unison-lang.org/docs/usage-topics/resetting-codebase-state))
- [Parallel Map-Reduce Tools](https://awesome-repositories.com/f/data-databases/parallel-data-transformation/parallel-data-reducers/parallel-map-reduce-tools.md) — Performs a distributed map-reduce operation across nodes with minimal code using a remote execution ability. ([source](https://unison-lang.org/))
- [Definition Deletions](https://awesome-repositories.com/f/data-databases/record-deletion/workflow-deletions/definition-deletions.md) — Allows deleting definitions from the codebase by removing them from a scratch file during an update workflow. ([source](https://unison-lang.org/docs/usage-topics/workflow-how-tos/update-code))

### Development Tools & Productivity

- [Codebase Stores](https://awesome-repositories.com/f/development-tools-productivity/content-addressable-stores/codebase-stores.md) — Stores all code definitions by their content hash, eliminating dependency conflicts and enabling instant non-breaking renames.
- [Branch Creation](https://awesome-repositories.com/f/development-tools-productivity/branch-management/branch-creation.md) — Duplicate the current branch into a new child branch and switch to it, optionally specifying a source branch. ([source](https://unison-lang.org/docs/tooling/project-workflows))
- [Code Sharing Utilities](https://awesome-repositories.com/f/development-tools-productivity/code-sharing-utilities.md) — Pushes code to a hosted repository for sharing and pulls from it to access others' code. ([source](https://unison-lang.org/docs/usage-topics/general-faqs))
- [Delayed IO Executions](https://awesome-repositories.com/f/development-tools-productivity/command-line-io-handlers/delayed-io-executions.md) — Executes programs that perform IO and raise exceptions directly from the command line. ([source](https://unison-lang.org/docs/at-a-glance))
- [Compiler Caches](https://awesome-repositories.com/f/development-tools-productivity/compiler-caches.md) — Compiles only changed definitions and caches results permanently by hash.
- [HTTP Request](https://awesome-repositories.com/f/development-tools-productivity/cron-scheduling/http-request.md) — Ships a built-in ability for making HTTP requests with effect handlers. ([source](https://unison-lang.org/))
- [Effectful HTTP Requests](https://awesome-repositories.com/f/development-tools-productivity/cron-scheduling/http-request/effectful-http-requests.md) — Provides a core mechanism for making HTTP requests within the Unison effect system. ([source](https://unison-lang.org/docs))
- [Definition Updates with Propagation](https://awesome-repositories.com/f/development-tools-productivity/package-dependency-managers/automated-dependency-updaters/automated-dependency-updaters/definition-updates-with-propagation.md) — Updates definitions from scratch files and automatically propagates changes to dependents. ([source](https://unison-lang.org/docs))
- [Dependent-Aware Definition Updates](https://awesome-repositories.com/f/development-tools-productivity/package-dependency-managers/automated-dependency-updaters/automated-dependency-updaters/dependent-aware-definition-updates.md) — Replaces existing definitions with newer versions and automatically updates all transitive dependents in the codebase. ([source](https://unison-lang.org/docs/at-a-glance))
- [Pull Request Review Interfaces](https://awesome-repositories.com/f/development-tools-productivity/pull-request-review-interfaces.md) — Provides a web interface for inspecting changes and merging pull requests. ([source](https://unison-lang.org/docs/tooling/project-workflows))
- [Text Literals](https://awesome-repositories.com/f/development-tools-productivity/string-literal-handling/text-literals.md) — Embed a sequence of Unicode characters, including multi-line strings with triple quotes and escape sequences. ([source](https://unison-lang.org/docs/language-reference/literals))
- [Character Literals](https://awesome-repositories.com/f/development-tools-productivity/string-literal-handling/text-literals/character-literals.md) — Represent a single Unicode character prefixed by ?, supporting escape sequences. ([source](https://unison-lang.org/docs/language-reference/literals))
- [Scratch File Editing](https://awesome-repositories.com/f/development-tools-productivity/terminal-syntax-highlighting-engines/in-browser-code-editing/scratch-file-editing.md) — Ships a scratch-file editing workflow where definitions are opened, modified, and applied to the codebase with automatic dependent updates. ([source](https://unison-lang.org/docs/usage-topics/workflow-how-tos/update-code))
- [Branch Permission Management](https://awesome-repositories.com/f/development-tools-productivity/branch-management/branch-permission-management.md) — Manages branch permissions for collaborative development with contributor branches. ([source](https://unison-lang.org/docs/tooling/unison-share))
- [Local Branch Listings](https://awesome-repositories.com/f/development-tools-productivity/branch-management/local-branch-listings.md) — Show all local branches of a project along with their remote mappings on Unison Share. ([source](https://unison-lang.org/docs/tooling/project-workflows))
- [Ability-Based Delays](https://awesome-repositories.com/f/development-tools-productivity/command-line-io-handlers/delayed-io-executions/ability-based-delays.md) — Marks blocks of code for deferred execution using do, underscore arguments, or the ' symbol. ([source](https://unison-lang.org/docs))
- [Dependency Installers](https://awesome-repositories.com/f/development-tools-productivity/dependency-installers.md) — Downloads the latest release of a library from the hosting service with a single command. ([source](https://unison-lang.org/docs/tooling/unison-share))
- [Dependency Installers](https://awesome-repositories.com/f/development-tools-productivity/dependency-managers/installation-resolution-utilities/dependency-installers.md) — Provides a command to add a project to the lib directory for use as a dependency, optionally specifying a version. ([source](https://unison-lang.org/docs/tooling/project-workflows))
- [Merge Conflict Resolution](https://awesome-repositories.com/f/development-tools-productivity/merge-conflict-resolution.md) — Opens conflicting definitions from merged branches in a scratch file for resolution and commits the merged result. ([source](https://unison-lang.org/docs/usage-topics/workflow-how-tos/update-code))
- [Curated Library Catalogs](https://awesome-repositories.com/f/development-tools-productivity/package-discovery/modular-package-catalogers/curated-library-catalogs.md) — Provides a curated catalog for discovering public projects by name, author, or description. ([source](https://unison-lang.org/docs/tooling/unison-share))
- [Dependent Review Flagging](https://awesome-repositories.com/f/development-tools-productivity/version-control-repository-tools/version-management-tooling/version-manager-updaters/dependency-cascade-updaters/dependent-review-flagging.md) — Replaces definitions with newer versions and automatically updates dependents, flagging any that require manual review. ([source](https://unison-lang.org/docs/projects))
- [Branch Change Logs](https://awesome-repositories.com/f/development-tools-productivity/workspace-management/project-workspaces/categorization/change/branch-change-logs.md) — Displays a log of changes made to the current branch, showing the command that produced each change. ([source](https://unison-lang.org/docs/usage-topics/resetting-codebase-state))
- [Cross-Branch Change Logs](https://awesome-repositories.com/f/development-tools-productivity/workspace-management/project-workspaces/categorization/change/cross-branch-change-logs.md) — Shows a log of changes across all branches in a project, including the names of terms or types that changed. ([source](https://unison-lang.org/docs/usage-topics/resetting-codebase-state))

### DevOps & Infrastructure

- [Content-Addressed Incremental Compilations](https://awesome-repositories.com/f/devops-infrastructure/cicd-pipeline-automation/core-build-engines/build-tooling/code-transformation-engines/incremental-compilation-strategies/content-addressed-incremental-compilations.md) — Store code as its AST in a content-addressed database to eliminate full rebuilds and provide perfect incremental compilation. ([source](https://cdn.jsdelivr.net/gh/unisonweb/unison@trunk/README.md))
- [Typed Transactional Storage](https://awesome-repositories.com/f/devops-infrastructure/cloud-storage-adapters/typed-transactional-storage.md) — Provides native typed transactional storage for values and functions without serialization.
- [Semantic Change Trackers](https://awesome-repositories.com/f/devops-infrastructure/dependency-management/version-compatibility-management/semantic-versioning-systems/semantic-change-trackers.md) — Tracks code changes by meaning rather than text, ignoring formatting and import order while providing perfect incremental compilation and cached test results. ([source](https://cdn.jsdelivr.net/gh/unisonweb/unison@trunk/README.md))
- [Branch Merging Strategies](https://awesome-repositories.com/f/devops-infrastructure/infrastructure/version-control-systems/branch-merging-strategies.md) — Provides built-in commands for merging branches and namespaces to combine work. ([source](https://unison-lang.org/docs/tooling/project-workflows))
- [Local-Remote Branch Synchronizers](https://awesome-repositories.com/f/devops-infrastructure/version-control-management/version-control-utilities/branch-management-utilities/local-remote-branch-synchronizers.md) — Synchronizes local branches with remote counterparts on the hosting service. ([source](https://unison-lang.org/docs/tooling/project-workflows))
- [Cloud Service Deployers](https://awesome-repositories.com/f/devops-infrastructure/cloud-deployment/cloud-service-deployers.md) — Deploys long-running services, serverless functions, and batch jobs to the cloud by calling a typed function. ([source](https://unison-lang.org/docs/what-problems-does-unison-solve))
- [Dependency-Aware Test Caches](https://awesome-repositories.com/f/devops-infrastructure/test-stage-caching/dependency-aware-test-caches.md) — Rerun only tests whose dependencies changed, reusing cached results for all other tests to speed up test suites. ([source](https://cdn.jsdelivr.net/gh/unisonweb/unison@trunk/README.md))
- [Dependency Versioning](https://awesome-repositories.com/f/devops-infrastructure/version-upgrades/dependency-versioning.md) — Installs new library versions and resolves conflicts across dependent code to update project dependencies. ([source](https://unison-lang.org/docs/usage-topics/workflow-how-tos/update-code))
- [Ability-Based Suspensions](https://awesome-repositories.com/f/devops-infrastructure/workflow-run-management/stateful-run-resumption/ability-based-suspensions.md) — Delays computation execution until the appropriate ability handlers are available for resumption. ([source](https://unison-lang.org/docs/fundamentals/abilities/for-monadically-inclined))

### Programming Languages & Runtimes

- [Content-Addressed Code Stores](https://awesome-repositories.com/f/programming-languages-runtimes/content-addressed-code-stores.md) — Stores all code as ASTs in a content-addressed database, eliminating builds and enabling instant non-breaking renames. ([source](https://unison-lang.org/))
- [Anonymous Functions](https://awesome-repositories.com/f/programming-languages-runtimes/anonymous-functions.md) — Define an anonymous function using the syntax p1 p2 … pn -> body. ([source](https://unison-lang.org/docs/language-reference/literals))
- [Boolean Logic Types](https://awesome-repositories.com/f/programming-languages-runtimes/boolean-logic-types.md) — Represent truth values directly as true or false in source code. ([source](https://unison-lang.org/docs/language-reference/literals))
- [Binary Data Literals](https://awesome-repositories.com/f/programming-languages-runtimes/byte-sequence-handling/binary-data-literals.md) — Embed raw binary data as an even number of hexadecimal digits prefixed by 0xs. ([source](https://unison-lang.org/docs/language-reference/literals))
- [Concurrency Primitives](https://awesome-repositories.com/f/programming-languages-runtimes/concurrency-primitives.md) — Provides MVar, TVar, and STM primitives for lock-free concurrent data structures. ([source](https://unison-lang.org/docs))
- [Conditional Branching](https://awesome-repositories.com/f/programming-languages-runtimes/conditional-branching.md) — Choose between code paths using if/else expressions or pattern matching with guards and variable binding. ([source](https://unison-lang.org/docs))
- [Continuation Invocation](https://awesome-repositories.com/f/programming-languages-runtimes/continuation-passing-style/continuation-invocation.md) — Optionally call the continuation of an ability constructor to resume the program, possibly with modified arguments. ([source](https://unison-lang.org/docs/language-reference/pattern-matching-on-ability-constructors))
- [Custom Infix Operators](https://awesome-repositories.com/f/programming-languages-runtimes/custom-infix-operators.md) — Define a binary operator using either prefix or infix notation, with optional qualified names for namespacing. ([source](https://unison-lang.org/docs/language-reference/operator-definitions))
- [Scratch File Evaluators](https://awesome-repositories.com/f/programming-languages-runtimes/expression-evaluators/scratch-file-evaluators.md) — Executes any expression prefixed with > in a .u file and displays the result for interactive development. ([source](https://unison-lang.org/docs/at-a-glance))
- [External Library Installers](https://awesome-repositories.com/f/programming-languages-runtimes/external-library-installers.md) — Downloads libraries from the hosting service into the local codebase for use as dependencies. ([source](https://unison-lang.org/docs))
- [Continuation Discarding](https://awesome-repositories.com/f/programming-languages-runtimes/first-class-continuations/continuation-discarding.md) — Ignore the continuation of an ability constructor to abort or short-circuit the program's execution. ([source](https://unison-lang.org/docs/language-reference/pattern-matching-on-ability-constructors))
- [Polymorphic Effect Passings](https://awesome-repositories.com/f/programming-languages-runtimes/function-argument-passing/polymorphic-effect-passings.md) — Supports polymorphic effect passing where higher-order functions accept any ability. ([source](https://unison-lang.org/docs/fundamentals/abilities/using-abilities-pt1))
- [Function Definitions](https://awesome-repositories.com/f/programming-languages-runtimes/function-definitions.md) — Define a named function with parameters in a scratch file and evaluate it immediately with a watch expression. ([source](https://unison-lang.org/docs))
- [Recursive Definitions](https://awesome-repositories.com/f/programming-languages-runtimes/function-definitions/recursive-definitions.md) — Allow a term's definition to refer to itself, enabling computations that repeat until a base case is reached. ([source](https://unison-lang.org/docs/language-reference/term-definition))
- [List Construction and Transformations](https://awesome-repositories.com/f/programming-languages-runtimes/functional-transformations/list-construction-and-transformations.md) — Create lists with square brackets, concatenate them, and apply transformations using pipe operators and lambda functions. ([source](https://unison-lang.org/docs))
- [Pattern Matching](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/language-features/control-flow/pattern-matching.md) — Provides pattern matching with variable binding, guards, and as-patterns for branching logic. ([source](https://unison-lang.org/docs/at-a-glance))
- [Data Constructor Decompositions](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/language-features/control-flow/pattern-matching/data-constructor-decompositions.md) — Provides constructor pattern matching to decompose data types and bind fields. ([source](https://unison-lang.org/docs/fundamentals/control-flow/pattern-matching2))
- [Numeric Literals](https://awesome-repositories.com/f/programming-languages-runtimes/numeric-literals.md) — Define integer and floating-point values directly in source code using standard numeric syntax. ([source](https://unison-lang.org/docs/language-reference/literals))
- [Pattern Bindings](https://awesome-repositories.com/f/programming-languages-runtimes/pattern-bindings.md) — Capture matched values into named variables that are accessible within the match body. ([source](https://unison-lang.org/docs/language-reference/match-expressions-and-pattern-matching))
- [Type Constructor Applications](https://awesome-repositories.com/f/programming-languages-runtimes/primary-constructors/type-constructor-applications.md) — Apply a type constructor to a type argument, analogous to function application at the term level. ([source](https://unison-lang.org/docs/language-reference/type-application))
- [Effect-Oriented Languages](https://awesome-repositories.com/f/programming-languages-runtimes/programming-language-varieties/programming-languages/effect-oriented-languages.md) — An effect-oriented language with content-addressed storage enabling semantic version control and distributed computation.
- [Tuple Destructuring](https://awesome-repositories.com/f/programming-languages-runtimes/programming-utilities/data-structure-type-helpers/pattern-based-destructuring/tuple-destructuring.md) — Deconstruct tuples by matching each element against a corresponding sub-pattern. ([source](https://unison-lang.org/docs/language-reference/match-expressions-and-pattern-matching))
- [Tuple Literals](https://awesome-repositories.com/f/programming-languages-runtimes/programming-utilities/data-structure-type-helpers/pattern-based-destructuring/tuple-destructuring/tuple-literals.md) — Group multiple values of possibly different types inside parentheses, including the unit tuple (). ([source](https://unison-lang.org/docs/language-reference/literals))
- [Structural Type Equivalences](https://awesome-repositories.com/f/programming-languages-runtimes/programming-utilities/data-structure-type-helpers/structural-type-equivalences.md) — Supports structural type equivalence based on identical constructors and arguments. ([source](https://unison-lang.org/docs/fundamentals/data-types/unique-and-structural-types))
- [Effect Signature Annotations](https://awesome-repositories.com/f/programming-languages-runtimes/programming-utilities/functional/generic-function-definitions/function-signature-enforcement/effect-signature-annotations.md) — Exposes effect requirements in function signatures using curly brace annotations. ([source](https://unison-lang.org/docs/fundamentals/abilities/using-abilities-pt1))
- [Auto-Generated Accessors and Mutators](https://awesome-repositories.com/f/programming-languages-runtimes/record-types/auto-generated-accessors-and-mutators.md) — Automatically generates getter, setter, and modifier functions for record fields. ([source](https://unison-lang.org/docs/fundamentals/data-types/record-types))
- [IO Program Execution](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-execution-environments/runtime-environments/runtimes/asynchronous-execution-engines/asynchronous-programming/io-program-execution.md) — Executes terms requiring IO and Exception abilities directly from the command-line interface. ([source](https://unison-lang.org/docs/usage-topics/general-faqs))
- [Type Annotations](https://awesome-repositories.com/f/programming-languages-runtimes/type-annotations.md) — Attach a type constraint to an expression so the compiler verifies the expression's type matches the declared type. ([source](https://unison-lang.org/docs/language-reference/type-annotations))
- [Type-Based Function Discovery](https://awesome-repositories.com/f/programming-languages-runtimes/type-based-function-discovery.md) — Enables discovering functions by their type signatures directly within the codebase. ([source](https://unison-lang.org/docs/the-big-idea))
- [Unique Type Identifiers](https://awesome-repositories.com/f/programming-languages-runtimes/type-name-assignment/unique-type-identifiers.md) — Assign a universally unique identifier to a type declaration so it is not confused with structurally identical types from other declarations. ([source](https://unison-lang.org/docs/language-reference/unique-types))
- [Custom Data Type Declarations](https://awesome-repositories.com/f/programming-languages-runtimes/type-name-assignment/unique-type-identifiers/custom-data-type-declarations.md) — Define custom data types as unique or structural, including recursive types with type parameters and record types with named fields. ([source](https://unison-lang.org/docs))
- [Scoped Type Variables](https://awesome-repositories.com/f/programming-languages-runtimes/variable-scope-controls/scoped-type-variables.md) — Keep type variables from a term's signature in scope throughout its definition, enabling consistent type references across the body. ([source](https://unison-lang.org/docs/language-reference/scoped-type-variables))
- [Continuation Capturing Handlers](https://awesome-repositories.com/f/programming-languages-runtimes/effectful-computation-merging/continuation-capturing-handlers.md) — Captures program continuations after effects occur, allowing handlers to run custom behavior and resume execution. ([source](https://unison-lang.org/docs/fundamentals/abilities))
- [Recursive Handlers](https://awesome-repositories.com/f/programming-languages-runtimes/effectful-computation-merging/continuation-capturing-handlers/recursive-handlers.md) — Pass the handler itself as the ability provider for continuations, enabling stateful or iterative handling. ([source](https://unison-lang.org/docs/language-reference/pattern-matching-on-ability-constructors))
- [Expression Evaluators](https://awesome-repositories.com/f/programming-languages-runtimes/expression-evaluators.md) — Executes any Unison expression in a scratch file and prints the result to the console. ([source](https://unison-lang.org/docs))
- [Watch](https://awesome-repositories.com/f/programming-languages-runtimes/expression-evaluators/watch.md) — Evaluates any Unison expression in a source file and prints the result to the console when the file is saved. ([source](https://unison-lang.org/docs/quickstart))
- [Literal Matching](https://awesome-repositories.com/f/programming-languages-runtimes/literal-matching.md) — Check whether a scrutinee equals a specific Boolean, Nat, Int, Char, or Text value and match only on exact equality. ([source](https://unison-lang.org/docs/language-reference/literal-patterns))
- [Typed Link Literals](https://awesome-repositories.com/f/programming-languages-runtimes/literal-suffixes/typed-link-literals.md) — Create a typed reference to a term or type using termLink or typeLink. ([source](https://unison-lang.org/docs/language-reference/literals))
- [Ability-Based Exception Handlers](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-exception-handling/ability-based-exception-handlers.md) — Implements exception handling where errors are raised as ability requests and caught by dedicated handlers. ([source](https://unison-lang.org/docs))
- [Pure Exception Converters](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-exception-handling/pure-exception-converters.md) — Catches failures raised by abilities and converts them into standard result types like Either. ([source](https://unison-lang.org/docs/fundamentals/abilities/for-monadically-inclined))

### Web Development

- [Ability-Based](https://awesome-repositories.com/f/web-development/effect-systems/ability-based.md) — Defines the core effect system of the language, using abilities and continuations.
- [Constructor Interception](https://awesome-repositories.com/f/web-development/effect-systems/ability-based/constructor-interception.md) — Match ability constructors in a handler to intercept and respond to requests made by a computation. ([source](https://unison-lang.org/docs/language-reference/pattern-matching-on-ability-constructors))
- [Pattern-Based Handlers](https://awesome-repositories.com/f/web-development/effect-systems/ability-based/pattern-based-handlers.md) — Match ability requests and pure computations in ability handlers using constructor and continuation patterns. ([source](https://unison-lang.org/docs/language-reference/match-expressions-and-pattern-matching))

### Artificial Intelligence & ML

- [Automatic Dependent Propagation](https://awesome-repositories.com/f/artificial-intelligence-ml/codebase-change-summarization/automatic-dependent-propagation.md) — Automatically updates all transitive dependents of a changed definition when the new type is compatible. ([source](https://unison-lang.org/docs/usage-topics/general-faqs))
- [Global Change Logs](https://awesome-repositories.com/f/artificial-intelligence-ml/codebase-change-summarization/global-change-logs.md) — Displays a log of changes across the entire codebase, not limited to a single project or branch. ([source](https://unison-lang.org/docs/usage-topics/resetting-codebase-state))
- [Interactive Codebase Browsers](https://awesome-repositories.com/f/artificial-intelligence-ml/knowledge-graphs/codebase-dependency-mapping/interactive-codebase-browsers.md) — Provides a desktop application for clicking through source definitions, searching terms, and reading API documentation. ([source](https://unison-lang.org/docs/tooling/ucm-desktop))

### Part of an Awesome List

- [LSP-Integrated Environments](https://awesome-repositories.com/f/awesome-lists/devtools/integrated-development-environments/lsp-integrated-environments.md) — Integrates with an LSP server to provide syntax highlighting, autocomplete, error highlighting, and type-on-hover in editors. ([source](https://unison-lang.org/docs/quickstart))
- [Head and Tail Decompositions](https://awesome-repositories.com/f/awesome-lists/devtools/lists-and-grids/head-and-tail-decompositions.md) — Provides head/tail list decomposition syntax for pattern matching. ([source](https://unison-lang.org/docs/fundamentals/control-flow/pattern-matching2))
- [Pattern Matching](https://awesome-repositories.com/f/awesome-lists/devtools/pattern-matching.md) — Evaluate a scrutinee against a sequence of patterns and execute the first matching branch's body. ([source](https://unison-lang.org/docs/language-reference/match-expressions-and-pattern-matching))
- [As-Pattern Bindings](https://awesome-repositories.com/f/awesome-lists/devtools/pattern-matching/as-pattern-bindings.md) — Provides as-pattern syntax for simultaneous whole-and-part binding during pattern matching. ([source](https://unison-lang.org/docs/fundamentals/control-flow/pattern-matching2))
- [List Decompositions](https://awesome-repositories.com/f/awesome-lists/devtools/pattern-matching/list-decompositions.md) — Decompose lists by matching on head/tail, init/last, literal elements, or concatenation splits. ([source](https://unison-lang.org/docs/language-reference/match-expressions-and-pattern-matching))
- [Pattern Guards](https://awesome-repositories.com/f/awesome-lists/devtools/pattern-matching/pattern-guards.md) — Add a Boolean guard expression to a pattern that must evaluate to true for the match to succeed. ([source](https://unison-lang.org/docs/language-reference/match-expressions-and-pattern-matching))
- [Fixed-Length Segment Matches](https://awesome-repositories.com/f/awesome-lists/devtools/pattern-matching/variable-length-segment-matching/fixed-length-segment-matches.md) — Supports matching lists with exact element counts using constructor syntax. ([source](https://unison-lang.org/docs/fundamentals/control-flow/pattern-matching2))
- [LSP Integration](https://awesome-repositories.com/f/awesome-lists/devtools/lsp-integration.md) — Exposes syntax highlighting, autocomplete, and type-on-hover through an LSP interface.
- [Init and Last Matches](https://awesome-repositories.com/f/awesome-lists/devtools/pattern-matching/list-decompositions/init-and-last-matches.md) — Match a list against all elements except the last and the final element, supporting symmetric decomposition. ([source](https://unison-lang.org/docs/language-reference/list-patterns))
- [Literal Element Sequence Matches](https://awesome-repositories.com/f/awesome-lists/devtools/pattern-matching/variable-length-segment-matching/fixed-length-segment-matches/literal-element-sequence-matches.md) — Match a list only when its length and each element match a fixed sequence of patterns. ([source](https://unison-lang.org/docs/language-reference/list-patterns))
- [List Concatenation Matches](https://awesome-repositories.com/f/awesome-lists/devtools/pattern-matching/variable-length-segment-matching/list-concatenation-matches.md) — Match a list as the concatenation of two sublists when at least one sublist has a known length. ([source](https://unison-lang.org/docs/language-reference/list-patterns))
- [Text Manipulation](https://awesome-repositories.com/f/awesome-lists/devtools/text-manipulation.md) — Search and split text strings using built-in functions or flexible regex-like patterns. ([source](https://unison-lang.org/docs))
- [More to explore](https://awesome-repositories.com/f/awesome-lists/more/more-to-explore.md) — Programming language with content-addressed code.

### Business & Productivity Software

- [Remote Project Downloads](https://awesome-repositories.com/f/business-productivity-software/project-collaboration-tools/remote-project-downloads.md) — Enables downloading any project or branch from the hosting service for local development. ([source](https://unison-lang.org/docs/tooling/project-workflows))
- [Reading and Writing Tools](https://awesome-repositories.com/f/business-productivity-software/knowledge-content-creation/reading-and-writing-tools.md) — Provides file read and write operations through standard library functions. ([source](https://unison-lang.org/docs))

### Graphics & Multimedia

- [Effect Composition Signatures](https://awesome-repositories.com/f/graphics-multimedia/audio-music/audio-processing/effects-processing/effect-chains/effect-composition-signatures.md) — Allows combining multiple effect requirements in a single type signature. ([source](https://unison-lang.org/docs/fundamentals/abilities/using-abilities-pt1))

### Networking & Communication

- [Distributed Computing](https://awesome-repositories.com/f/networking-communication/distributed-systems-p2p/distributed-computing.md) — Runs computations on remote machines by specifying where they should execute, with dependencies deployed automatically. ([source](https://unison-lang.org/))
- [Ability-Based Distributed Executors](https://awesome-repositories.com/f/networking-communication/distributed-systems-p2p/distributed-computing/ability-based-distributed-executors.md) — Runs computations across remote nodes using an effect system that handles dependency deployment and execution without external frameworks.
- [Bytecode Shipping Engines](https://awesome-repositories.com/f/networking-communication/distributed-systems-p2p/distributed-computing/bytecode-shipping-engines.md) — Ships a function's bytecode tree to a remote location and syncs missing dependencies on the fly for distributed execution. ([source](https://unison-lang.org/docs/the-big-idea))
- [Type-Safe Remote Calls](https://awesome-repositories.com/f/networking-communication/remote-procedure-calls/type-safe-remote-calls.md) — Enables type-safe remote service calls without writing encoders or decoders. ([source](https://unison-lang.org/docs/what-problems-does-unison-solve))
- [Computation Abortions](https://awesome-repositories.com/f/networking-communication/request-abort-controllers/computation-abortions.md) — Ships a language-level abort mechanism that stops function execution on condition. ([source](https://unison-lang.org/docs/fundamentals/abilities/using-abilities-pt1))

### Security & Cryptography

- [Sandboxed Execution Environments](https://awesome-repositories.com/f/security-cryptography/remote-access-security/sandboxed-execution-environments.md) — Restrict what abilities and resources a computation from a peer can access, enforcing security policies at runtime. ([source](https://unison-lang.org/docs/usage-topics/general-faqs))

### Software Engineering & Architecture

- [Algebraic Data Types](https://awesome-repositories.com/f/software-engineering-architecture/abstract-data-types/algebraic-data-types.md) — Defines custom types with named data constructors carrying typed arguments. ([source](https://unison-lang.org/docs/fundamentals/data-types/unique-and-structural-types))
- [Purity Annotations](https://awesome-repositories.com/f/software-engineering-architecture/architectural-design-patterns/design-patterns/functional-design-patterns/pure-functional-logic-implementations/purely-functional-derivations/purity-annotations.md) — Marks pure functions with empty brace annotations in type signatures. ([source](https://unison-lang.org/docs/fundamentals/abilities/using-abilities-pt1))
- [Ability Declarations](https://awesome-repositories.com/f/software-engineering-architecture/declarative-effect-mapping/ability-declarations.md) — Implements ability declarations that define effect interfaces with named operations. ([source](https://unison-lang.org/docs/fundamentals/abilities/using-abilities-pt1))
- [Signature Subset Checking](https://awesome-repositories.com/f/software-engineering-architecture/declarative-effect-mapping/ability-declarations/signature-subset-checking.md) — Check that every function call's required abilities are a subset of the abilities declared in the enclosing function's type signature. ([source](https://unison-lang.org/docs/language-reference/the-typechecking-rule-for-abilities))
- [Serialization-Free Persistences](https://awesome-repositories.com/f/software-engineering-architecture/default-configuration-values/database-value-generation/serialization-free-persistences.md) — Stores and retrieves values directly without requiring serialization or translation code. ([source](https://unison-lang.org/))
- [Graceful Version Coexistence](https://awesome-repositories.com/f/software-engineering-architecture/library-conflict-resolution/graceful-version-coexistence.md) — Allows multiple versions of the same type or function to coexist in the codebase without breaking builds. ([source](https://unison-lang.org/docs/the-big-idea))
- [Hash-Based Dependency References](https://awesome-repositories.com/f/software-engineering-architecture/named-dependency-resolution/hash-based-dependency-references.md) — References definitions by content hash, allowing multiple library versions to coexist without name conflicts. ([source](https://unison-lang.org/))
- [Content-Addressed Renamings](https://awesome-repositories.com/f/software-engineering-architecture/naming-conventions/identifier-renaming/content-addressed-renamings.md) — Change a definition's name everywhere at once without breaking references, because functions are identified by their implementation hash. ([source](https://cdn.jsdelivr.net/gh/unisonweb/unison@trunk/README.md))
- [Pull Request Submissions](https://awesome-repositories.com/f/software-engineering-architecture/project-management-governance/project-governance/contribution-guidelines/pull-request-workflows/pull-request-submissions.md) — Ships a workflow for creating contributor branches and submitting them as pull requests. ([source](https://unison-lang.org/docs/tooling/project-workflows))
- [Project Initializations](https://awesome-repositories.com/f/software-engineering-architecture/project-management-governance/project-management/open-source-governance/project-management/project-initializations.md) — Create an empty project with a default main branch, optionally accepting a custom or random name. ([source](https://unison-lang.org/docs/tooling/project-workflows))
- [Branch-Based Project Organization](https://awesome-repositories.com/f/software-engineering-architecture/project-structure-organization/branch-based-project-organization.md) — Divides the codebase into separate projects with branches and dependency namespaces to structure libraries and applications. ([source](https://unison-lang.org/docs/quickstart))
- [Side Effect Handlers](https://awesome-repositories.com/f/software-engineering-architecture/side-effect-handlers.md) — Manages side effects like I/O, exceptions, and state through typed abilities and handlers instead of monads or callbacks.
- [Surgical Code Refactoring](https://awesome-repositories.com/f/software-engineering-architecture/surgical-code-refactoring.md) — Provides interactive, type-checked refactoring sessions that keep the codebase live and avoid misleading error lists. ([source](https://unison-lang.org/))
- [Nominal Type Distinctions](https://awesome-repositories.com/f/software-engineering-architecture/typescript-type-definitions/schema-driven-type-inference/branded-types/nominal-type-distinctions.md) — Provides nominal type distinction preventing substitution of structurally identical types. ([source](https://unison-lang.org/docs/fundamentals/data-types/unique-and-structural-types))
- [Abort-Based Handlers](https://awesome-repositories.com/f/software-engineering-architecture/error-handling-patterns/abort-based-handlers.md) — Provides abort-based error handling where failures are silently converted to Optional values through ability handlers. ([source](https://unison-lang.org/docs/fundamentals/abilities/error-handling))
- [Failure Value Handlers](https://awesome-repositories.com/f/software-engineering-architecture/error-handling-strategies/monadic-error-handling/failure-value-handlers.md) — Ships exception-based error handling where structured Failure values are raised and can be translated to Either. ([source](https://unison-lang.org/docs/fundamentals/abilities/error-handling))
- [Throw-Based Error Handlers](https://awesome-repositories.com/f/software-engineering-architecture/error-handling-strategies/monadic-error-handling/throw-based-error-handlers.md) — Provides throw-based error handling where typed error values are returned and can be translated to Either. ([source](https://unison-lang.org/docs/fundamentals/abilities/error-handling))
- [Namespace-to-Project Conversions](https://awesome-repositories.com/f/software-engineering-architecture/project-management-governance/project-management/project-lifecycle-management/project-presences/namespace-to-project-conversions.md) — Convert an existing namespace or published library into a project by merging its contents into a new project's branches. ([source](https://unison-lang.org/docs/tooling/project-workflows))
- [Project Visibility Control](https://awesome-repositories.com/f/software-engineering-architecture/project-management-governance/project-management/project-visibility-control.md) — Sets a hosted project as private or public to control access and visibility. ([source](https://unison-lang.org/docs/tooling/unison-share))
- [Ability Composition](https://awesome-repositories.com/f/software-engineering-architecture/side-effect-handlers/railway-side-effects/ability-composition.md) — Composes computations using different abilities like exception handling and I/O without monadic combinators. ([source](https://unison-lang.org/docs/fundamentals/abilities/for-monadically-inclined))

### Testing & Quality Assurance

- [Value Property Assertions](https://awesome-repositories.com/f/testing-quality-assurance/software-testing/testing-frameworks/test-frameworks/assertions-and-validation/assertion-validation-utilities/assertion-libraries/execution-assertions/assertion-failure-handlers/value-property-assertions.md) — Check conditions like equality, ordering, or truth with functions that provide detailed failure messages. ([source](https://unison-lang.org/docs/usage-topics/testing))
- [Unit Testing Frameworks](https://awesome-repositories.com/f/testing-quality-assurance/unit-testing-frameworks.md) — Execute all tests in a namespace or project, reporting results and caching outcomes for unchanged dependencies. ([source](https://unison-lang.org/docs/usage-topics/testing))
- [Distributed Runtime Simulations](https://awesome-repositories.com/f/testing-quality-assurance/local-network-simulators/distributed-runtime-simulations.md) — Simulates cloud execution on a single machine using the Cloud client library for testing and development. ([source](https://unison-lang.org/docs/usage-topics/general-faqs))
- [Effect-Based Test Backends](https://awesome-repositories.com/f/testing-quality-assurance/software-testing/e2e-integration-testing/distributed-systems-testing/effect-based-test-backends.md) — Separate business logic from implementation via an effect system, enabling distributed computation to run against test backends for observability or performance. ([source](https://unison-lang.org/docs/what-problems-does-unison-solve))
- [Property-Based Fuzzing](https://awesome-repositories.com/f/testing-quality-assurance/software-testing/test-execution-orchestration/test-case-generators/property-based-fuzzing.md) — Generate random or enumerated test cases and check that a property holds for all of them, reporting failures with details. ([source](https://unison-lang.org/docs/usage-topics/testing))
- [Random Value Generators](https://awesome-repositories.com/f/testing-quality-assurance/software-testing/test-execution-orchestration/test-case-generators/random-value-generators.md) — Produce random integers, naturals, or floats for test inputs, including edge cases like zero and boundary values. ([source](https://unison-lang.org/docs/usage-topics/testing))

### Content Management & Publishing

- [Project Page Hosting](https://awesome-repositories.com/f/content-management-publishing/project-page-hosting.md) — Automatically displays a README document as the project's homepage on the hosting service. ([source](https://unison-lang.org/docs/tooling/unison-share))

### Operating Systems & Systems Programming

- [File I/O Utilities](https://awesome-repositories.com/f/operating-systems-systems-programming/system-administration-maintenance/file-system-management/file-systems/file-i-o-utilities.md) — Provides standard library functions for reading and writing files under the FilePath and Handle namespaces. ([source](https://unison-lang.org/docs/at-a-glance))
- [Remote Library Installers](https://awesome-repositories.com/f/operating-systems-systems-programming/systems-programming/shared-library-development/remote-library-installers.md) — Download the latest or a specific version of a library from Unison Share into the codebase. ([source](https://unison-lang.org/docs/at-a-glance))