These articles are for developers to learn the high-level concepts of Rhovas, such as motivation and key features. For detailed documentation see the Docs pages instead.


Welcome! Rhovas is a programming language intended for API design and enforcement. Using Rhovas, developers can better express the contracts and intention of their code to help create maintainable, correct, and performant software.

This page provides a quick overview of the key concepts driving the language. For more details, see also:

  • Motivation: Why is Rhovas being created?
  • Language Tour: What is Rhovas like to program in?
  • History: How did Rhovas start, and what happened along the way?

Language Design

Rhovas has three "pillars" of language design goals which are used to evaluate and prioritize design decisions for the language:

  1. Maintainability: How easily can the software be understood and modified to incorporate bug fixes, new features, or specification changes?
  2. Correctness: Does the software perform the desired task as intended, and how can the intended behavior be documented and tested?
  3. Performance: Is the efficiency of the software sufficient when considering latency, memory, or other resources?

These principles are considered ordered. Software that is performant but not correct does not achieve the desired task, while correct software can continue to improve performance. Similarly, code that is correct but not maintainable may function at one point in time but is not resilient to changes as the software evolves (breaking correctness), while maintainable code can be adapted to become correct. Though this is a simplified approach, the prioritization of these principles has been beneficial for establishing and maintaining a clear vision for Rhovas.

APIs, Dependencies, & Maintainability

All software has multiple layers of APIs - dependencies, modules, classes, all the way to functions - specifying how that individual component of the software operates. Modern software has more dependencies than ever before, and even internal projects are split into separate modules or have different developers (such as past you, they're an idiot).

These dependencies present enough challenges at any given moment, but when factoring in changes over time they introduce plenty more issues ranging from small bugs to security vulnerabilities to take-down-the-internet-left-pad incidents.

Rhovas is one of the few languages to specifically design features for this problem, such as identifying changes that would break API/ABI compatibility. Rhovas also supports functionality for API migrations to make it easier to update dependencies, ranging from renaming functions to transforming larger sections of the codebase through macros (safely, of course!).


Rhovas can be roughly classified as a strong, statically typed, and Object-Oriented language that prefers Functional paradigms (similar to Kotlin). Rhovas prefers structs over classes, declarative over imperative, and pure over mutating; however these features are all available and it is ultimately up to the developer to determine the right level of complexity for the given problem.

Furthermore, since Rhovas currently runs on the JVM it is consequently garbage-collected. While some thought has been given to supporting manual memory management eventually, it is not a design goal - there are other languages spending far more effort in this area than Rhovas (such as Cone and Vale) that are better for safe low-level programming which we can steal from later.

Rhovas itself was inspired by a wide variety of language, most notably Kotlin/Java as well as C++, JavaScript/TypeScript, Swift, Rust, and Elixir. Specific features were also inspired by Eiffel's Design by Contract philosophy, Pony's reference capabilities, Midori's error model, and Racket's macro system.