Stats
dotnet/runtimelab is an open source project licensed under MIT License which is an OSI approved license.
Runtimelab Alternatives
Similar projects and alternatives to runtimelab
-
-
-
Scout APM
Scout APM - Leading-edge performance monitoring starting at $39/month. Scout APM uses tracing logic that ties bottlenecks to source code so you know the exact line of code causing performance issues and can get back to building a great product faster.
-
-
corert
This repo contains CoreRT, an experimental .NET Core runtime optimized for AOT (ahead of time compilation) scenarios, with the accompanying compiler toolchain.
-
-
llilc
This repo contains LLILC, an LLVM based compiler for .NET Core. It includes a set of cross-platform .NET code generation tools that enables compilation of MSIL byte code to LLVM supported platforms.
-
-
-
-
awesome-dot-net-performance
A curated list of awesome .NET Performance books, courses, trainings, conference talks, blogs and most inspiring open source contributors. Inspired by awesome-... stuff.
-
-
-
-
-
-
Cocona
Micro-framework for .NET Core console application. Cocona makes it easy and fast to build console applications on .NET Core.
-
-
BlazorWebFormsComponents
A collection of Blazor components that emulate the ASP.NET Web Forms controls of the same name
-
-
Vrmac
Vrmac Graphics, a cross-platform graphics library for .NET. Supports 3D, 2D, and accelerated video playback. Works on Windows 10 and Raspberry Pi4.
Posts
- anyone know how to compile a .net 5 console application to a smaller exe?
-
C# 9 top-level programs and target-typed expressions
I think the short answer to your question is "no".
For single-file-no-project simplicity your best bet is dotnet-script: https://github.com/filipw/dotnet-script
For native code your best bet is NativeAOT: https://github.com/dotnet/runtimelab/tree/feature/NativeAOT
I'm not aware of anything that combines the two.
As to why: it's not so much that they've made it hard as they haven't made it easy. The reason they haven't made it easy is that it's a fringe use case. The main benefits of AOT are faster startup time, smaller storage requirements, and compliance with the iOS interpreted language ban. Most people who worry about those things don't mind having a project file.
They _have_ made some changes that may partly address your concerns. Visual Studio is no longer required to build C#; you can do it purely from the command line. There is also a new project file format. it's still XML, but much simpler. The HelloWorld example[0] from NativeAOT is a good example of how simple it can get. And the command line tools include an easy way of creating a basic project files[1], so you don't have to memorize what little boilerplate remains.
[0] https://github.com/dotnet/runtimelab/tree/feature/NativeAOT/...
- What exactly is C#?
-
Awesome .NET Performance
What does AOT have to do with benchmarks that don't use AOT and report great performance?
Also you're dramatically overstating how mature AOT is for dotnet
https://github.com/dotnet/runtimelab/tree/feature/NativeAOT
>This repo is for experimentation and exploring new ideas that may or may not make it into the main dotnet/runtime repo.
- Is it possible to call a .NET Core-compiled C# function from a C++ application?
-
Why Discord is switching from Go to Rust
> the JIT needs warmup just like java
You can use ReadyToRun[0] to pre-JIT portions of the code for faster startup. Full AOT compilation is in the works too[1] albeit it's still experimental.
[0]: https://docs.microsoft.com/en-us/dotnet/core/deploying/ready...
[1]: https://github.com/dotnet/runtimelab/tree/feature/NativeAOT
-
"Low Level" questions about C# (and .Net)
NativeAOT
-
My preferred .NET console stack – An opinionated view on .NET console apps
CoreRT was an experiment and it's concluded. The learnings and components like RyuJIT have now been moved to the new project called NativeAOT.
My understanding is the opposite; now that they're planning to merge Mono and CoreCLR, there is significantly more pressure on the .NET team to have a proper AOT solution.
"Early adopters can experiment with native AOT form factor" is a priority-zero (highest priority) epic for .NET 6: https://github.com/dotnet/runtimelab/issues/248
-
is there a way to turn .net programs into native like c++ programs?
Yes. Appears they renamed it "GitHub - dotnet/runtimelab at feature/NativeAOT" https://github.com/dotnet/runtimelab/tree/feature/NativeAOT
-
Make smaller console apps with .NET and CoreRT
That was definitely the plan for .NET 5 when it was still in; however I'm not sure about that for .NET 6 as https://github.com/dotnet/runtimelab has 3 variants of NativeAoT
-
Any reason to not use AOT with C#?
CoreRt isn't really being worked on anymore; its migrated to NativeAOT in https://github.com/dotnet/runtimelab
- Moving to C++ with a very strong background in C#. Am I ready?
- NativeAOT (formerly CoreRT) is coming (back) to .NET