A massively parallel, optimal functional runtime in Rust (by HigherOrderCO)

HVM Alternatives

Similar projects and alternatives to HVM

  • Kind

    4 HVM VS Kind

    A next-gen functional language [Moved to: https://github.com/Kindelia/Kind2] (by Kindelia)

  • fslang-suggestions

    The place to make suggestions, discuss and vote on F# language and core library features

  • Mergify

    Updating dependencies is time-consuming.. Solutions like Dependabot or Renovate update but don't merge dependencies. You need to do it manually while it could be fully automated! Add a Merge Queue to your workflow and stop caring about PR management & merging. Try Mergify for free.

  • rust-gpu

    - HVM VS rust-gpu

    🐉 Making Rust a first-class language and ecosystem for GPU shaders 🚧

  • Vale

    4 HVM VS Vale

    Compiler for the Vale programming language - http://vale.dev/ (by ValeLang)

  • SICL


    A fresh implementation of Common Lisp

  • Sharp-Bilinear-Shaders

    sharp bilinear shaders for RetroPie, Recalbox and Libretro for sharp pixels without pixel wobble and minimal blurring

  • atom

    - HVM VS atom

    A DSL for embedded hard realtime applications. (by tomahawkins)

  • InfluxDB

    Collect and Analyze Billions of Data Points in Real Time. Manage all types of time series data in a single, purpose-built database. Run at any scale in any environment in the cloud, on-premises, or at the edge.

  • hylo

    4 HVM VS hylo

    The Hylo programming language

  • ixy-languages

    A high-speed network driver written in C, Rust, C++, Go, C#, Java, OCaml, Haskell, Swift, Javascript, and Python

  • frag

    3 HVM VS frag

    Frag is a 3D first person shooting game written in Haskell, by Mun Hon Cheong

  • Lua

    - HVM VS Lua

    Lua is a powerful, efficient, lightweight, embeddable scripting language. It supports procedural programming, object-oriented programming, functional programming, data-driven programming, and data description.

  • rust

    2 HVM VS rust

    Empowering everyone to build reliable and efficient software.

  • julia

    2 HVM VS julia

    The Julia Programming Language

  • carbon-lang

    Carbon Language's main repository: documents, design, implementation, and related tools. (NOTE: Carbon Language is experimental; see README)

  • zig

    2 HVM VS zig

    General-purpose programming language and toolchain for maintaining robust, optimal, and reusable software.

  • rayon

    2 HVM VS rayon

    Rayon: A data parallelism library for Rust

  • ponyc

    Pony is an open-source, actor-model, capabilities-secure, high performance programming language

  • Kind2

    2 HVM VS Kind2

    A next-gen functional language [Moved to: https://github.com/Kindelia/Kind]

  • koka

    2 HVM VS koka

    Koka language compiler and interpreter

  • futhark

    2 HVM VS futhark

    :boom::computer::boom: A data-parallel functional programming language

  • SonarQube

    Static code analysis for 29 languages.. Your projects are multi-language. So is SonarQube analysis. Find Bugs, Vulnerabilities, Security Hotspots, and Code Smells so you can release quality code every time. Get started analyzing your projects today for free.

NOTE: The number of mentions on this list indicates mentions on common posts plus user suggested alternatives. Hence, a higher number means a better HVM alternative or higher similarity.

HVM reviews and mentions

Posts with mentions or reviews of HVM. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2023-06-06.
  • Can one use lambda calculus as an IR?
    3 projects | /r/Compilers | 6 Jun 2023
    The most recent exploration of this, that I'm aware of is HVM (another intermediate language / runtime), although this one is not actually based on the lambda calculus, but on the interaction calculus.
  • The Rust I Wanted Had No Future
    4 projects | /r/rust | 5 Jun 2023
    Then, actually unrelated but worth mentioning: HVM. Finally, something new on the functional front that isn't dependent types!
  • The Halting Problem Is Decidable on a Set of Asymptotic Probability One (2006)
    2 projects | news.ycombinator.com | 28 May 2023
  • For those of you self taught,how did you cope with distractions while using a computer ?
    2 projects | /r/ADHD_Programmers | 8 May 2023
    In the interest of seeking ways of optimizing my code, I stumbled upon http://www.rntz.net/datafun/ as a means to do incremental computations of fixpoints while avoiding redundant work. And also the idea of automatic parallelism achieved by using Interaction Nets as a model of computation https://github.com/HigherOrderCO/HVM.
  • [P] I built a chatbot that lets you talk to any Github repository
    4 projects | /r/MachineLearning | 2 Apr 2023
    I tried on https://github.com/HigherOrderCo/HVM but it couldn't load any .rs file it seems.
  • Higher-Order Virtual Machine (HVM)
    5 projects | news.ycombinator.com | 27 Mar 2023
    The HVM project is incredibly interesting and I applaud the great work Victor Taelin has put in practically implementing Interaction Nets and popularising Linear Logic.

    I've noticed HVM since February last year and was quite convinced that they were really up to something; however now that I've gone through a pile of papers on Linear Logic and the book which HVM is based on (The Optimal Implementation of Functional Programming Languages, Asperti and Guerrini, https://www.amazon.co.jp/-/en/Andrea-Asperti/dp/0521621127), I believe that among other things, the issue presented here https://github.com/HigherOrderCO/HVM/issues/60 is really a fundamental blocker to serving as a general purpose runtime, which it appears HVM attempts at.

    Fundamentally HVM is an impressively optimised implementation of Symmetric Interaction Combinators, a variety of Interaction Net. Symmetric Interaction Combinators is not related to lambda calculus in a trivial way, and thus as noted in the README, HVM does not 'support' the full Lambda Calculus. In a vast majority of cases the HVM approach really does simply evaluate lambda terms at impressive speed, but the failure cases are quite tricky to handle, in that they will fail silently, simply evaluating the term incorrectly. This issue however, is acknowledged in the README and can be tackled by the method described there, or by type-checking for these 'failure' cases https://github.com/HigherOrderCO/HVM/discussions/97.

    The issue mentioned in #60 however, seems to be quite fundamental - HVM makes lambda evaluation fast by implementing lambda evaluation in terms of Symmetric Interaction Combinators and making sure each operation SIC evaluates in constant time. This works in most cases, but as acknowledged in Asperti and Guerrini, in some cases the SIC representation of lambda terms simply become themselves very (exponentially) large. Victor appears to acknowledge that he is simply building a practical counterpart upon the theory as cited from Asperti and Guerrini, citing Asperti and Guerrini's 'safe rules', which has not yet been implemented, as his plan to prevent very large representations of lambda terms from occurring, but Asperti and Guerrini themselves acknowledge that their rules are probably incomplete.

    The promise of HVM is that we have finally found a way to naturally implement the parallelism inherent in pure lambda terms, without special annotation or extra accommodation for the runtime. As it stands, HVM still falls short of the lofty dream.

    5 projects | news.ycombinator.com | 27 Mar 2023
    This is where I do my best to NOT get too excited, but predictability is one of the most exciting aspects of HVM to me. That's because everything is linear, there are no thunks, so both memory and space usage is very predictable, in a way that feels like C, but even further, I'd say, since costs are completely measurable. For example, in the following GitHub issue:


    I discuss how HVM is able to perform deforestin (one of the core techniques that made GHC so fast) "for free" at runtime, without being explicitly hardcoded, and being more general. Which is great, but the point I'd like to make here is how I show that: by measuring 'rewrite count' of different implementations with HVM's '-c' flag. It shows you how much space and "graph rewrites" a program evaluation took. Since each rewrite is a constant time operation, this gives you a very precise metric on the complexity of a program.

    For example, on the issue above, I implemented two versions of the same function, and measured their rewrite counts. Here are the tables:

        Fn V1
    5 projects | news.ycombinator.com | 27 Mar 2023
  • Brett Slatkin: Why am I building a new functional programming language?
    10 projects | news.ycombinator.com | 5 Mar 2023
    See also the Higher-Order Virtual Machine for a functional, non-garbage-collected, and parallel runtime: https://github.com/HigherOrderCO/HVM
  • Ask HN: Burnt out from big tech. What's next?
    2 projects | news.ycombinator.com | 9 Feb 2023
  • A note from our sponsor - Mergify
    blog.mergify.com | 24 Sep 2023
    Solutions like Dependabot or Renovate update but don't merge dependencies. You need to do it manually while it could be fully automated! Add a Merge Queue to your workflow and stop caring about PR management & merging. Try Mergify for free. Learn more →


Basic HVM repo stats
15 days ago

HigherOrderCO/HVM is an open source project licensed under MIT License which is an OSI approved license.

The primary programming language of HVM is Rust.

Static code analysis for 29 languages.
Your projects are multi-language. So is SonarQube analysis. Find Bugs, Vulnerabilities, Security Hotspots, and Code Smells so you can release quality code every time. Get started analyzing your projects today for free.