robertmuth / awesome-low-level-programming-languages Goto Github PK

val-lang
https://github.com/robertmuth/awesome-low-level-programming-languages#val
renamed to hylo

citate from https://github.com/hylo-lang/hylo
"Warning. Val is getting renamed to Hylo. We apologize for any broken links and confusion this may cause. We're working on it."

new links:
https://www.hylo-lang.org
https://github.com/hylo-lang/hylo

You can check more here:
https://www.tuple.nl/blog/all-you-need-to-know-about-low-level-languages
https://www.coursereport.com/blog/a-guide-to-low-level-programming-for-beginners

This implements C2 fibonacci:

func i32 fib(int n)
{
    i32 a = 0;
    i32 b = 1;
    for (i32 i = 0; i < n; i++) {
       i32 c = a + b;
       a = b;
       b = c;
    }
    return a;
}

This implements fibonacci for C3:

fn int fib(int n)
{
    int a = 0;
    int b = 1;
    for (int i = 0; i < n; i++) {
       int c = a + b;
       a = b;
       b = c;
    }
    return a;
}

Please update Cone entry...

Highlights:

• Regions for memory management versatility/safety
• Permissions for thread versatility/safety
• Delegated inheritance and structural subtyping
• Variant types (three flavors)
• Actors
• Generic functions, types and modules

Fibonacci example

// Fibonacci

import stdio::*

fn fib(n i64) i64:
mut prior i64 = 0
mut result i64 = 1
while n-- > 0:
prior, result = result, prior + result
result

fn main():
print <- fib(6)

From readme:

**Excluded are languages relying on managed run-times and without manual memory management.**

C# has MMM(like Rust unsafe + some references), it has GC, it has AOT of time compile. For example C# has modules compiled for C++ consumption by its JIT and by UEFI.

For inclusion listed:

[Roc](https://www.roc-lang.org/),

Roc has GC, has no MMM, but it is AOT compiled. So it must not be included.

So not clear what you mean by managed run-time?

I propose next inclusion criteria:

Languages inclusion is not considered if  summary of these states are mostly true:
- AOT native target compiler is not default main target. JIT or interpreted only languages are excluded.
- Default  coding style produces binaries which has friction to be called and consumed by other MMM languages. GC and green threads are typical examples of friction.
- MMM can be done only via unsafe or without default coding style language abstractions

With these C# and Roc will not be included.

With original definition C# must be included (it runs in UEFI and also AOT compiled for consumtion by JIT written in C++.

Also C# is very popular in games, and some OS written in C# too :) .

It seems that the example of Carp is a duplication of Cone. AFAIK, Carp is a language with Lisp syntax and should not be like this. Please help to fix it. Thanks.