Bflat Alternatives

bflat reviews and mentions

• A review after using Rust on embedded in production for over a year
  7 projects | news.ycombinator.com | 14 Oct 2024

  You can :) It just requires going out of your way a bit. It effectively works as C with better type system and generics, that can be either JIT or AOT compiled (statically linked too). For example https://github.com/bflattened/bflat has a target flavour that does not support GC at all.

• Pledging $300k to the Zig Software Foundation
  6 projects | news.ycombinator.com | 1 Oct 2024

  There is a practical answer to this question: https://github.com/bflattened/bflat specifically the --stdlib:zero target.

  C# is quite a bit more than just enhanced C if you remove GC-reliant features as the generics and interface constraints enable a huge subset of features, alongside SIMD API, stack-allocated buffers and all sorts of memory wrappable in Spans, which almost every method in the standard library that works on some sort of buffer accepts nowadays instead of plain arrays.

• Microsoft donates the Mono Project to the Wine team
  30 projects | news.ycombinator.com | 27 Aug 2024

  Static fields may be placed on Frozen Object Heap. The values of static readonly fields may not exist at all if the ILC's static constructor interpreter can pre-initialize it at compile-time and bake the value into binary or codegen. DynamicPGO does a similar optimization but for all cases, relying on recompilation. This is with JIT though which is not usable in such environment.

  There is no concept of globals in .NET the way you describe it - you simply access static properties and fields.

  In practice, you will not be running .NET on microcontrollers with existing mainline runtime flavours - very different tradeoffs, much like no-std in Rust. As mentioned, there is NanoFramework. Another one is https://www.wildernesslabs.co which my friend is using for an automated lab for his PhD thesis.

  Last mention goes to https://github.com/bflattened/bflat which supports a few interesting targets like UEFI. From the same author there's an example of completely runtime-less C# as well: https://github.com/MichalStrehovsky/zerosharp. It remains a usable language because C# has a large subset of C and features for manual memory management so writing code that completely bypasses allocations is very doable, unlike most other GC-based languages.

• Borgo is a statically typed language that compiles to Go
  21 projects | news.ycombinator.com | 30 Apr 2024

  The sibling pretty much sums it up. But if you want more detail, read on:

  Generally, there are three publishing options that each make sense depending on scenario:

  JIT + host runtime: by definition portable, includes slim launcher executable for convenience, the platform for which can be specified with e.g. -r osx-arm64[0].

  JIT + self-contained runtime: this includes IL assemblies and runtime together, either within a single file or otherwise (so it looks like AOT, just one bin/exe). These requires specifying RID, like in the previous option.

  AOT: statically linked native binary, cross-OS compilation is not supported officially[1] because macOS is painful in general, and Windows<->Linux/FreeBSD is a configuration nightmare - IL AOT Compiler depends on Clang or MSVC and a native linker so it is subject to restrictions of those as a start. But it can be done and there are alternate, more focused toolchains, that offer it, like Bflat[1].

  If you just want a hello world AOT application, then the shortest path to that is `dotnet new console --aot && dotnet publish -o {folder}`.

  [0] https://learn.microsoft.com/en-us/dotnet/core/rid-catalog

  [1] https://github.com/bflattened/bflat (can also build UEFI binaries, lol)

• Learn how to build beautiful and interactive .NET command-line applications using System.CommandLine and Spectre.Console with my latest blog post
  1 project | /r/dotnet | 5 Jul 2023

  See here

• Question about NativeAOT platform support
  4 projects | /r/dotnet | 30 May 2023

  See B flat

• Native AOT Overview
  8 projects | news.ycombinator.com | 26 May 2023

  I've been wondering how to integrate modern .NET Core into a custom build system (buck2) and was wondering similar things. There's this project I think is cool called bflat[1] that basically makes the C# compiler more like the Go compiler in the sense it's a one-shot single-use tool that can cross compile binaries natively. It's done by one of the people on the .NET Runtime team as a side project, but quite neat.

  I think in practice you're supposed to compile whole .dll's or assemblies all at once, which acts as the unit of compilation; I don't think the csharp compiler generates native object-files-for-every-.cs, the kind of approach you'd expect from javac or g++. Someone please correct me if I'm wrong though! I'd like to learn more about this.

  [1] https://github.com/bflattened/bflat

• If you were stuck on a remote island, would you pick C# as your programming language
  2 projects | /r/csharp | 11 Feb 2023

  You can compile without a GC using https://github.com/bflattened/bflat

• AOT
  3 projects | /r/fsharp | 16 Jan 2023
• Hey people, made a game for my CS homework as a freshman using C#, what do you guys think about it?
  4 projects | /r/csharp | 11 Jan 2023

  nice. have you tried compile it using https://github.com/bflattened/bflat to have native executable? as long as you don't have PackgeReference it can be compiled using bflat instead of full dotnet

• A note from our sponsor - SaaSHub
  www.saashub.com | 25 Apr 2025

  SaaSHub helps you find the best software and product alternatives Learn more →