constantine VS nimkernel

Percival cache attacks on Hyperthreading.

I go over some examples here: https://github.com/mratsim/constantine/issues/358#issuecomme...

`when myCondition():` instead of `if myCondition:` is done at compile-time.

Alternatively you can use a `static:` code block to force compile time evaluation. Or tag a function {.compileTime.} or tag function inputs with `static` modifier.

It is possible to create a compiler or an assembler running fully in Nim macros as well:

- https://github.com/mratsim/constantine/blob/master/constanti... (all that file runs at compile-time)

You can also implement Continuation-Passing-Style transformation at compile-time:

At a glance this sounds like a re-discovery of addition chains and using them to construct Pippenger algorithm. But applied to matrices instead of group elements.

See: https://github.com/mratsim/constantine/issues/37

I usually explain extension fields as similar to complex numbers with regards to reals.

I've collected a lot of extension fields references while working on my own implementation: https://github.com/mratsim/constantine/tree/master/constanti...

The best likely being

- Arithmetic of Finite Fields

Regarding your first question, you don't need to attack the hard-drive, for non constant-time crypto you can read power consumption or electromagnetic traces when the secret key is used to reconstruct it: - https://github.com/mratsim/constantine/wiki/Constant-time-arithmetics

Unfortunate name collision with my constant-time pairing-based cryptography library :/.

https://github.com/mratsim/constantine

KZG for sure yes, I actually already started implementing them: https://github.com/mratsim/constantine/tree/c2d716b/research/kzg_poly_commit

I have a small write-up on various details of elliptic curve crypto implementation here: https://github.com/mratsim/constantine/tree/master/constantine/elliptic

> kernel developers do not allow third party runtimes in the kernel. Even meager Rust's "panic" runtime is a contentious

Much in Linux is contentious :-) which is why the module system is nice. A kernel module for C code requires no permission from Linux-core unless you need it distributed with the kernel (which, yes, might be required for "credibility" - but critically also might not). It may require many decls to access various kernel APIs, but those can be (semi-)automated or just done as-needed. So, Linux kernel policy is not so relevant (at best) which is what I meant by "no special support" (admittedly brief). Kernel coding is always a bit trickier, and you may need to build up some support code to make integration nice, though as well as decl generators.

> Can one disable runtime in Nim completely -- no GC, no exceptions?

To answer your question, and as discussed elsewhere in this subthread, Nim has many options for memory management.. only stdlib seq/string really needs automatic methods. One can disable the runtime completely via os:standalone and statically check that no exceptions are raised with Nim's effect system (and there are also both setjmp & goto based exception impls which may/may not be workable in Linux/BSD kernel module settings). As "proof more by example", a few people have written OS kernels in Nim recently[1,2] and there was another toy kernel long ago[3].

People have also written OS kernels in Go which "has a GC and runtime".[4] So, I acknowledge it's not quite the same example, but I also see no fundamental blockers for kernel modules.

[1] https://github.com/khaledh/axiom

[2] https://prosepoetrycode.potterpcs.net/2023/01/a-barebones-ke...

[3] https://github.com/dom96/nimkernel

[4] https://github.com/mit-pdos/biscuit/

Niceness is subjective, but Nim is just as valid an addition to that group. Nim compiles to C and has had an --os=standalone mode for like 10 years from its git history, and as mentioned else-thread (https://news.ycombinator.com/item?id=36506087) can be used for Linux kernel modules. Multiple people have written "stub OSes" in it (https://github.com/dom96/nimkernel & further along https://github.com/khaledh/axiom).

While it can use clang as a backend, Nim does not rely upon LLVM support like Zig or Rust (pre-gcc-rust working). Use on embedded devices is fairly popular: https://forum.nim-lang.org/search?q=embedded (or web search).

Latency-wise, for a time, video game programming was a perceived "adoption niche" or maybe "hook" for Nim and games often have stringent frame rendering deadlines. If you are interested in video games, you might appreciate https://github.com/shish/rosettaboy which covers all but Ada in your list with Nim being fastest (on one CPU/version/compiler/etc). Note, however, that cross-PL comparisons are often done by those with much "porting energy" but limited familiarity with any but a few of the PLs. A better way to view it is that "Nim responds well to optimization effort" (like C/Ada/C++/Rust/Zig).