HVM VS ixy-languages

Compare HVM vs ixy-languages and see what are their differences.

HVM

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

ixy-languages

A high-speed network driver written in C, Rust, C++, Go, C#, Java, OCaml, Haskell, Swift, Javascript, and Python (by ixy-languages)
Our great sponsors
  • InfluxDB - Power Real-Time Data Analytics at Scale
  • WorkOS - The modern identity platform for B2B SaaS
  • SaaSHub - Software Alternatives and Reviews
HVM ixy-languages
107 30
6,981 2,108
2.5% 0.4%
6.7 0.0
29 days ago over 1 year ago
Rust TeX
MIT License BSD 2-clause "Simplified" License
The number of mentions indicates the total number of mentions that we've tracked plus the number of user suggested alternatives.
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.

HVM

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-11-12.
  • GPU Survival Toolkit for the AI age: The bare minimum every developer must know
    2 projects | news.ycombinator.com | 12 Nov 2023
  • A new F# compiler feature: graph-based type-checking
    9 projects | news.ycombinator.com | 5 Nov 2023
    I have a tangential question that is related to this cool new feature.

    Warning: the question I ask comes from a part of my brain that is currently melted due to heavy thinking.

    Context: I write a fair amount of Clojure, and in Lisps the code itself is a tree. Just like this F# parallel graph type-checker. In Lisps, one would use Macros to perform compile-time computation to accomplish something like this, I think.

    More context: Idris2 allows for first class type-driven development, where the types are passed around and used to formally specify program behavior, even down to the value of a particular definition.

    Given that this F# feature enables parallel analysis, wouldn't it make sense to do all of our development in a Lisp-like Trie structure where the types are simply part of the program itself, like in Idris2?

    Also related, is this similar to how HVM works with their "Interaction nets"?

    https://github.com/HigherOrderCO/HVM

    https://www.idris-lang.org/

    https://clojure.org/

    I'm afraid I don't even understand what the difference between code, data, and types are anymore... it used to make sense, but these new languages have dissolved those boundaries in my mind, and I am not sure how to build it back up again.

  • 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:

    https://github.com/HigherOrderCO/HVM/issues/167

    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

ixy-languages

Posts with mentions or reviews of ixy-languages. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2023-04-08.
  • The Garbage Collection Handbook, 2nd Edition
    6 projects | news.ycombinator.com | 8 Apr 2023
    Not really, here it is winning hands down over Swift's ARC implementation.

    https://github.com/ixy-languages/ixy-languages

  • rust devs in a nutshell
    2 projects | /r/ProgrammerHumor | 14 Feb 2023
  • “Rust is safe” is not some kind of absolute guarantee of code safety
    12 projects | /r/programming | 2 Oct 2022
  • I wrote a database engine in Typescript
    3 projects | /r/programming | 23 Sep 2022
    It's kind of funny when you see things like this project: https://github.com/ixy-languages/ixy-languages
  • What are my prospects in web programming, if I don't like JS?
    4 projects | /r/AskProgramming | 3 Sep 2022
    like not-even-in-the-same-ballpark faster. In this realworld example (userspace network drivers in managed languages) JS manages about 20-30% of native code performance, python iirc is below 1%
  • Don’t call it a comeback: Why Java is still champ
    17 projects | news.ycombinator.com | 9 Aug 2022
    - Support for generic-aware value types (struct vs. class) and low-level features like stackalloc: very valuable for high-performance scenarios and native FFI. See for instance https://github.com/ixy-languages/ixy-languages. In comparison, Java doesn't even have unsigned integers. Yes, Project Valhalla is coming someday.

    As well, debatable to some folks, but: properties (get/set); operator overloading; LINQ > Java streams; extension methods; default parameters; collection initializers; tuples; nullable reference types; a dozen smaller features

  • Reference Count, Don't Garbage Collect
    9 projects | news.ycombinator.com | 29 Jul 2022
    https://github.com/ixy-languages/ixy-languages

    The real reason why a tracing GC was a failure in Objective-C was due to the interoperability with the underlying C semantics, where anything goes.

    The implementation was never stable enough beyond toy examples.

    Naturally automating the Cocoa release/retain calls made more sense, given the constraints.

    In typical Apple fashion they pivoted into it, gave the algorithm a fancy name, and then in a you're holding it wrong style message, sold their plan B as the best way in the world to manage memory.

    When Swift came around, having the need to easily interop with the Objective-C ecosystem naturally meant to keep the same approach, otherwise they would need the same machinery that .NET uses (RCW/CCW) to interop with COM AddRef/Release.

    What Apple has is excellent marketing.

    9 projects | news.ycombinator.com | 29 Jul 2022
  • Why did you switch from another language to Rust? Do you regret not learning it earlier?
    9 projects | /r/rust | 25 Jul 2022
    Can you recommend a good example of an actual project's build-management to look at? Because looking at the gradle examples https://docs.gradle.org/current/samples/sample_building_java_applications.html and https://docs.gradle.org/current/samples/sample_building_java_applications.html or the setup guide for a numerics library https://nm.dev/wiki/tutorials/setupguide/ it sure looks terrible and is in no way comparable to rust, having more of a CMake flavor for gradle and a "no management whatsoever" flavor for the numerics thing. It also doesn't speak for java's ecosystem that for example https://github.com/ixy-languages/ixy-languages does not run on newer versions because of unsupported dependencies. That said imo "bad build system / dependency management" is not an uncommon problem / most languages have terrible systems.
    9 projects | /r/rust | 25 Jul 2022
    It also doesn't speak for java's ecosystem that for example https://github.com/ixy-languages/ixy-languages does not run on newer versions because of unsupported dependencies

What are some alternatives?

When comparing HVM and ixy-languages you can also consider the following projects:

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

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

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

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

ctl - The C Template Library

atom - A DSL for embedded hard realtime applications.

redgrep - ♥ Janusz Brzozowski

Vale - Compiler for the Vale programming language - http://vale.dev/

cats - Lightweight, modular, and extensible library for functional programming.

c-examples - Example C code

actix-web - Actix Web is a powerful, pragmatic, and extremely fast web framework for Rust.