# Reliable programming languages

> AI-ranked search results for `high reliability languages` on awesome-repositories.com — ordered by an LLM for relevance, best match first. 117 total matches; showing the top 15.

Explore on the web: https://awesome-repositories.com/q/high-reliability-languages

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [this search on awesome-repositories.com](https://awesome-repositories.com/q/high-reliability-languages).**

## Results

- [coq/coq](https://awesome-repositories.com/repository/coq-coq.md) (5,488 ⭐) — Coq is an interactive theorem prover and proof assistant used for formal mathematical verification and verified software development. It utilizes the Gallina functional language to define computable functions and logical propositions, which are then verified through a machine-checked kernel.

The system employs a dependent type system and a Caldicott-style proof engine to automate proof search and tactic execution. These capabilities allow for the creation of formal specifications and the development of algorithms that are mathematically proven to meet specific requirements.

The toolset inclu
- [carbon-language/carbon-lang](https://awesome-repositories.com/repository/carbon-language-carbon-lang.md) (33,829 ⭐) — Carbon is an experimental, compiled systems programming language designed as a successor to C++. It focuses on providing a high-performance environment for modern software development while prioritizing memory safety and expressive generic programming. The language is built to support performance-critical engineering, allowing for precise control over memory layout and execution flow.

A primary differentiator of the project is its bidirectional interoperability with existing C++ codebases. This allows developers to call functions and share data between languages without manual wrappers, facil
- [leanprover/lean4](https://awesome-repositories.com/repository/leanprover-lean4.md) (8,306 ⭐) — Lean 4 is a functional programming language and interactive proof assistant used to formalize mathematics and verify software correctness. It functions as a dependent type theorem prover and a formal verification tool that allows users to construct mathematical proofs and ensure program correctness. Additionally, it serves as a logic-based source for generating verified datasets used to train and benchmark artificial intelligence reasoning systems.

The system distinguishes itself through a small-kernel verification model, where all proofs are verified by a trusted core of basic logical rules.
- [rust-lang/rust](https://awesome-repositories.com/repository/rust-lang-rust.md) (114,066 ⭐) — Rust is a programming language designed for memory safety and performance. It provides a comprehensive curriculum that covers fundamental syntax, memory management, and advanced programming paradigms, including support for functional and object-oriented styles. The language features a strong type system that enforces memory safety through ownership, borrowing, and lifetime annotations, while also offering mechanisms for handling both recoverable and unrecoverable errors.

The language includes extensive support for concurrent programming, providing primitives for thread management, shared-stat
- [crablang/crab](https://awesome-repositories.com/repository/crablang-crab.md) (5,090 ⭐) — Crab is a memory-safe systems programming language and ahead-of-time compiler designed for high-performance software. It utilizes a type system based on strict ownership and borrowing rules to prevent memory access errors at compile time.

The toolchain includes an automated documentation generator that produces technical reference manuals and API guides by parsing structured source code annotations. It also features a dependency management tool to resolve external library graphs and ensure consistent project builds.

The project covers software build automation, static type checking, and mult
- [adacore/spark2014](https://awesome-repositories.com/repository/adacore-spark2014.md) (314 ⭐) — This repository contains the source code for the SPARK project. SPARK is a software development technology specifically designed for engineering high-reliability applications. It consists of a programming language, a verification toolset and a design method which, taken together, ensure that…
- [microsoft/bosquelanguage](https://awesome-repositories.com/repository/microsoft-bosquelanguage.md) (5,215 ⭐) — Bosque is an experimental programming language and development platform designed for machine-assisted software construction. It combines functional programming semantics with imperative syntax to enforce logic correctness and runtime safety, providing a type-safe environment that utilizes structured data models to maintain information integrity throughout the application lifecycle.

The platform distinguishes itself through deep integration with formal verification tools, including automated theorem provers and symbolic execution engines. By transforming source code into a regularized intermed
- [swiftlang/swift](https://awesome-repositories.com/repository/swiftlang-swift.md) (70,051 ⭐) — Swift is a high-performance, general-purpose programming language designed for safety and speed. It features a modular compiler front-end that transforms source code into optimized machine binaries, utilizing a value-oriented type system that prioritizes predictable state management through value and reference types. The language is built on a task-based concurrency model that schedules asynchronous operations across multicore hardware to ensure data race safety.

The project distinguishes itself through a native, bi-directional interoperability mechanism that allows for direct integration wit
- [crystal-lang/crystal](https://awesome-repositories.com/repository/crystal-lang-crystal.md) (20,299 ⭐) — Crystal is a statically typed, compiled programming language designed for high performance and memory safety. It leverages an LLVM-based compiler to translate source code into optimized machine-executable binaries, while its type-inference-based static analysis enforces strict safety rules during the build process.

The language distinguishes itself through a fiber-based concurrent runtime that manages lightweight execution units for asynchronous input and output without blocking the main process. It also features a powerful compile-time macro system that allows for the inspection and transfor
- [elixir-lang/elixir](https://awesome-repositories.com/repository/elixir-lang-elixir.md) (26,543 ⭐) — Elixir is a functional, concurrent programming language designed for building scalable and maintainable applications. It operates on the Erlang virtual machine, leveraging a distributed, fault-tolerant runtime environment that manages lightweight processes to ensure system reliability. By utilizing an actor-model supervision strategy, the language enables the creation of high-concurrency backend systems that automatically recover from failures and maintain stability under heavy loads.

The language distinguishes itself through a powerful metaprogramming environment that allows developers to ex
- [vlang/v](https://awesome-repositories.com/repository/vlang-v.md) (37,655 ⭐) — V is a statically typed, compiled programming language designed for high-performance systems development. It prioritizes memory safety and execution speed by enforcing strict type checking and immutable defaults, while generating native machine code for multiple hardware architectures. The language is built around an integrated toolchain that includes a compiler, package manager, formatter, and testing utilities within a single executable, facilitating rapid development cycles.

What distinguishes V is its focus on developer productivity and interoperability. It provides a direct interface for
- [flix/flix](https://awesome-repositories.com/repository/flix-flix.md) (2,585 ⭐) — Flix is a statically typed multi-paradigm programming language that combines functional, imperative, and logic programming paradigms within a single unified environment. It utilizes a constraint-driven execution environment to derive results by satisfying logical predicates rather than following linear sequential instructions.

The language features a unification-based logic engine designed to solve complex computational problems through term unification and backtracking. This is supported by a core library of persistent immutable data structures that ensure side-effect free state management a
- [koka-lang/koka](https://awesome-repositories.com/repository/koka-lang-koka.md) (3,936 ⭐) — Koka is a statically typed functional programming language featuring an algebraic effect system. It uses a strong type system to verify program correctness and track side effects at compile time.

The language is distinguished by a reference counting compiler that transforms source code into native C code, eliminating the need for a tracing garbage collector. It employs perceive-based in-place updates to reduce memory overhead and utilizes tail recursion modulo cons for constant-space data structure construction.

The system provides a comprehensive standard library covering numeric operations
- [odin-lang/odin](https://awesome-repositories.com/repository/odin-lang-odin.md) (9,806 ⭐) — Odin is a compiled, statically typed systems programming language designed for high-performance software development. It focuses on pragmatic low-level memory control, providing a toolset for manual memory management and precise control over hardware utilization.

The language is distinguished by its flexible memory model, which includes custom allocators and precise data layout capabilities to optimize resource usage. It features a comprehensive foreign function interface for importing assembly files and linking with external libraries using configurable calling conventions.

The type system
- [roc-lang/roc](https://awesome-repositories.com/repository/roc-lang-roc.md) (5,723 ⭐) — Roc is a statically typed, functional programming language built around immutable-by-default semantics, exhaustive pattern matching on tag unions, and a type system that combines optional explicit annotations with full compile-time type inference. Its core identity centers on correctness and expressiveness, using tagged unions for error handling with a question-mark operator for early error propagation, and a trailing-bang naming convention that makes side-effect boundaries syntactically visible at every call site.

The language distinguishes itself through a platform-based I/O abstraction tha