Who is out here building high-overhead parallelization libraries?

    ~ $ type cat
    cat is a function
    cat () 
    { 
        while read; do
            printf '%s\n' "$REPLY";
        done < "$@"
    }

Well we both ended up in CS but it's really a funny take nowadays (by then I wasn't so sure and it made me worry a bit).

Mono made a lot of sense for running places where full .NET didn't, like in full AOT environments like on the iPhone where you can't JIT, or for random architectures that don't matter anymore but once did for Linux (Alpha, Itanium, PPC, MIPs, etc.). When Microsoft bought Xamarin (which itself was born out of the ashes of the Novell shutdown of the Mono effort) and started the DotNET Core efforts to make .NET more portable itself and less a system-provided framework and merge in a lot of the stuff Mono did a single more focused project made more sense.

Mono was still left out there to support the edge cases where DotNET Core didn't make sense, which was mostly things like being a backend for Wine stuff in some cases, some GNOME Desktop stuff (via GTK#, which is pretty dead now), and older niche use cases (second life and Unity still embed mono as a runtime for their systems). The project was limping, though, and sharing a standard library but different runtimes after much merging. Mono's runtime was always a little more portable (C instead of C++) and more accessible to experiment with, but we need that less and less, but it's still perfect for Wine. So, having it live on in Wine makes sense. It's a natural fit.

Is there good documentation somewhere for getting set up to develop with modern .NET on Linux?

For example, just download .NET 8 SDK on whatever platform, which is usually very easy on most platforms, and then run `dotnet fsi` to get into an F# REPL.

This must be the most unfriendly Linux install documentation I've ever seen though, it was not easy to find the names of those packages.

It's not. Microsoft provides its own apt repository you need to add first.

$ apt search dotnet

p dotnet-apphost-pack-6.0 - Internal - targeting pack for Microsoft.NET p dotnet-apphost-pack-7.0 - Internal - targeting pack for Microsoft.NET p dotnet-apphost-pack-8.0 - Internal - targeting pack for Microsoft.NET p dotnet-host - dotNET host command line p dotnet-host-7.0 - dotNET host command line p dotnet-host-8.0 - .NET host command line p dotnet-hostfxr-6.0 - dotNET host resolver p dotnet-hostfxr-7.0 - dotNET host resolver p dotnet-hostfxr-8.0 - .NET host resolver p dotnet-runtime-6.0 - dotNET runtime p dotnet-runtime-7.0 - dotNET runtime p dotnet-runtime-8.0 - .NET runtime p dotnet-runtime-dbg-8.0 - .NET Runtime debug symbols. p dotnet-sdk-6.0 - dotNET 6.0 Software Development Kit p dotnet-sdk-6.0-source-built-arti - Internal package for building dotNet 6.0 So p dotnet-sdk-7.0 - dotNET 7.0 Software Development Kit p dotnet-sdk-7.0-source-built-arti - Internal package for building dotNet 7.0 So p dotnet-sdk-8.0 - .NET 8.0 Software Development Kit p dotnet-sdk-8.0-source-built-arti - Internal package for building the .NET 8.0 p dotnet-sdk-dbg-8.0 - .NET SDK debug symbols. p dotnet-targeting-pack-6.0 - Internal - targeting pack for Microsoft.NET p dotnet-targeting-pack-7.0 - Internal - targeting pack for Microsoft.NET p dotnet-targeting-pack-8.0 - Internal - targeting pack for Microsoft.NET p dotnet-templates-6.0 - dotNET 6.0 templates p dotnet-templates-7.0 - dotNET 7.0 templates p dotnet-templates-8.0 - .NET 8.0 templates p dotnet6 - dotNET CLI tools and runtime p dotnet7 - dotNET CLI tools and runtime p dotnet8 - .NET CLI tools and runtime p libgtk-dotnet3.0-cil - GTK.NET library p libgtk-dotnet3.0-cil-dev - GTK.NET library - development files

I've been using the script installer version intended for ci/cd as I actually like that installer more, it's the only one that really supports multiple versions correctly.

Does it not meet the DFSG?

It's been there for several years now, hasn't it?

To a point. Making cross platform native desktop apps is still in the hands of 3rd party vendors such as Avalonia and Uno. MAUI was supposed to fix that oversight to a less than stellar results.

So this "it's all for backend now" notion is surprising.

That's what you have to compare against, and .NET/C# falls flat.

Er, I don't think this assertion is backed by data. See for example https://pypl.github.io/PYPL.html

Is Kotlin the most "active", "hot", or "up-and-coming" competitor? Possibly. But the "largest"? Its deployed footprint and popularity are nowhere close to Java's at this point in time.

C# and F# get to enjoy the integration that is "much closer to the metal" as well as much richer cross-platform GUI frameworks ecosystem with longer history.

Win32? Silverlight/Blend? XAML? MAUI? They're all windows only.

Gtk? Qt? Sure, they exist, but they're ancient and limited to long outdated paradigms.

I don't know if you can get QtQuick with KDE Kirigami to work on .NET, otherwise that might be one option.

Kotlin Multiplatform is btw a solution for building the same code for kotlin native, JVM and web to target all the OSes at the same time.

While Jetpack Compose is the Android Version of Compose, Compose Multiplatform is Compose for Kotlin Multiplatform.

> subject to the quirks and specifics of JVM implementations, build-systems and package management

That's a massive advantage over the arcane package management and build systems of .NET

Very few languages ever achieve a build and package management system as mature and usable as the Java ecosystem.

I've been waiting for 12 years for .NET to match Java's ecosystem, and it's still not there yet.

> That's a massive advantage over the arcane package management and build systems of .NET. Very few languages ever achieve a build and package management system as mature and usable as the Java ecosystem. I've been waiting for 12 years for .NET to match Java's ecosystem, and it's still not there yet.

If you want to sell me on "advantages" of invoking Gradle or Maven over

    dotnet new web
    dotnet run
    curl localhost:port

    dotnet new console --aot
    echo 'Console.WriteLine($"Right now is {DateTime.Now}");' > Program.cs
    dotnet publish -o {here goes the executable}

    dotnet add package {my favourite package}

Also, what's up with Oracle suing companies for using incorrect JDK distribution that happens to come with hidden license strings attached?

Well, that's where the problem lies, isn't it? The ecosystem for .NET is extremely limited compared to what's available for the JVM

And the way JVM packages are distributed, with native libraries, BOMs and platforms allows more versatility than any other platform.

The build system may be better in dotnet, but that only really matters for the first 10 minutes. Afterwards, the other tradeoffs become much more important.

Nonetheless, you could make this argument for select Apache products, but that's Apache for you. It does not hold true for the larger ecosystem and, at the end of the day, quantity is not quality, otherwise we would've all been swept by Node.js :)

Same applies to "packages that bundle native libraries".

First, they are always maintenance-heavy to manage with ever growing matrix of platforms and architectures. Just x86 alone is problem enough as all kinds of codecs perform wildly different depending if AVX2 or 512 is available vs SSE4.2 or even SSE2 without EVEX. Now add ARM64 with and without SVE2 to the mix. Multiply this by 2 or 3 (if you care about macOS or FreeBSD). Multiply linux targets again by musl and glibc. You get the idea. This a worst-case scenario but it's something Java is not going to help you with and will only make your life more difficult due to the reason below.

There is also an exercise in writing JNI bindings. Or maybe using Java FFM now which still requires you to go through separate tooling, build stage, deal with off-heap memory management API and still does not change the performance profile significantly. There's a reason it is recommended to avoid native dependencies in Java and port them instead (even with performance sacrifices).* Green Threads will only exacerbate this problem.

Meanwhile

    using System.Runtime.InteropServices;

    [DllImport("libc", EntryPoint = "putchar")]
    static extern int PutChar(int c);

    var text = "Hello, World!\n";
    foreach (var c in text) PutChar(c);

(I'm not sure if binding process on the ole Mono was any different? In any case, the above is a thing on Linux since 8 years ago at least)

Like with other false claims, the "better native packaging" one is easily disprovable. Just look at the list of supported platforms here: https://github.com/sandrohanea/whisper.net?tab=readme-ov-fil...

It even supports CoreML on iOS and macOS.

* Now applies to C# too but for completely different reason - you can usually replace data crunching C++ code with portable pure C# implementation that retains 95% of original performance while reducing LOC count and complexity. Huge maintenance burden reduction and "it just works" without having to ship extra binaries or require users to pull extra dependencies.

I'm not sure if you've used JNA before? That's been the state of the art for many years: https://github.com/java-native-access/jna

    public interface MSVCRT extends Library {
        public static MSVCRT Instance = (MSVCRT) Native.load("msvcrt", MSVCRT.class);
    
        void printf(String format, Object... args);
    }

    public class HelloWorld {
        public static void main(String[] args) {
            MSVCRT.Instance.printf("Hello, World\n");
            for (int i=0;i < args.length;i++) {
                MSVCRT.Instance.printf("Argument %d: %s\n", i, args[i]);
            }
        }
    }

Sure, and it's got many great libraries – but actually using those is horrible.

You're absolutely right about Rust though. crates.io and cargo are amazing tools with a great ecosystem.

The primary issue I've got with the .NET ecosystem is actually closely related to that. Because it's so easy to import native libraries, often there's no .NET version of a library and everyone uses the native one instead. But if I actually want to build the native one I've got to work with ancient C++ build systems and all the arcane trouble they bring with them.

> Same applies to "packages that bundle native libraries".

You seem to have misunderstood. The fun part of the maven ecosystem is that a dependency doesn't have to be a jar, it can also be an XML that resolves to one or multiple dependencies depending on the environment.

What is the reason to continue making statements like this one? Surely we could discuss this without trying making accusations out of thin air? As the previous conversation indicates, you are not familiar with C# and its toolchain, and were wrong on previous points as demonstrated. It's nice to have back and forth banter on HN, I get to learn about all kinds of cool things! But this happens through looking into the details, verifying if prior assumptions are still relevant, reading documentation and actually trying out and dissecting the tools being discussed to understand how they work - Golang, Elixir, Swift, Clojure, etc.

> You seem to have misunderstood. The fun part of the maven ecosystem is that a dependency doesn't have to be a jar, it can also be an XML that resolves to one or multiple dependencies depending on the environment.

Same as above.

> JNA

I was not aware of it, thanks. It looks like the closest (even if a bit more involved) alternative to .NET's P/Invoke. Quick search indicates that it comes at an explicit huge performance tradeoff however.

From https://github.com/zakgof/java-native-benchmark?tab=readme-o...

"Now let's look into performance of the native call only, stripping out the struct allocation and field access:"

    Native call only (average time, smaller is better)

    JmhCallOnly.jna_direct   1373.435 ±  70.343  ns/op
    JmhCallOnly.jna          1346.036 ±  72.239  ns/op
    JmhCallOnly.bridj         383.992 ±  50.000  ns/op
    JmhCallOnly.jnr           298.334 ±  48.785  ns/op
    JmhCallOnly.jni_javacpp    56.605 ±   8.087  ns/op
    JmhCallOnly.foreign        49.717 ±   6.667  ns/op

That's definitely true, but it should be possible to reimplement JNA on top of the new FFM APIs for convenient imports and high performance at the same time.

> Of course the numbers can be presented in a much more .NET-favored way by including the allocations that Java has to do in the absence of structs and other C primitives.

Hopefully Project Valhalla will allow fixing that, the current workarounds aren't pretty.

I fully agree though that .NET is far superior in terms of native interop.

> As the previous conversation indicates, you are not familiar with C# and its toolchain,

I've been using .NET for far over a decade now. I even was at one of the hackathons for Windows Phone developers back in the day.

Sure, I haven't kept up with all the changes in the last 2-3 years because I've been so busy with work (which is Kotlin & Typescript).

That said, it doesn't seem like most of these changes have made it that far into real world projects either. Most of the .NET projects I see in the real world are years behind, a handful even still targeting .NET Framework.

> were wrong on previous points as demonstrated.

So far all we've got is a back and forth argument over the same few points, you haven't actually shown any of my points to be "wrong".

This conversation comes up from time to time. It is sometimes difficult to talk to developers who have a perception of .NET that predates .NET Core 3.1 or so and newer. Windows Phone and its tooling is older. I am sad UWP has died, the ecosystem needs something better than what we have today, and the way Apple does portability with MacCatalyst is absolutely pathetic. In a better timeline there exists open and multi-platform UWP-like abstraction adopted by everything. But these were other times and I digress.

The package distribution did not change significantly besides small things like not having to write .nuspec by hand in most situations. Nuget was already good and far ahead of the industry at the time it was introduced.

The main change was the switch to SDK-style projects files. Kind of like Cargo.toml but XML.

Adding a file to a nuget package (or anything else you build) is just adding a <Content ... /> item to an <ItemGroup>.

Adding custom MSBuild stage or behavior is done via .targets file for packaging purposes: https://learn.microsoft.com/en-us/nuget/concepts/msbuild-pro...

Which is why I linked you Whisper.net. It has a .targets file that manages platform-specific dependencies: https://github.com/sandrohanea/whisper.net/blob/main/Whisper....

As you can see, it is possible to make definitions conditional and use arbitrary information provided by the build system. It is very powerful. I don't know what made you think that I assume anything about .jar files.

For another example, look at these lines: https://github.com/U8String/U8String/blob/main/Examples/Inte...

Together with <PublishAot> property, invoking 'dotnet publish -o .' calls into cargo to build a static library from Rust, then compiles C# project, then compiles the produced .NET assemblies to native object files with ILC (IL AOT Compiler), and then calls system linker to statically link together .NET object files and a Rust object file into a final native binary. The calls across interop, as annotated, become direct C ABI calls + GC poll (a boolean check, multiple checks may be merged so less than a branch per call).

This produces just a single executable that you can ship to users. If you open it with Ghidra, it will look like weird C++. This is a new feature (.NET 7+) but even without NativeAOT, it was already possible to trim and bundle CIL assemblies into a single executable together with JIT and GC. As far as I'm aware, the closest thing that Java has is Graal Native Image, which is even more limited than NativeAOT at the present moment (IL linker has improved a lot and needs much less annotations, most of which can be added as attributes in code and the analyzer will guide you so you don't need trial and error). And the project that allows to embed bytecode in the .NET trimmed single-file style in Java is still very far from completion (if I understood it right).

I think https://two-wrongs.com/dotnet-on-linux-update is more or less representative of unbiased conclusions one makes when judging .NET by its merits today. You can always say "it used to be bad". Sure. It does not mean it still is, and the argument is irrelevant for greenfield projects, which is what I advocate C# is the better choice for anyway.

> I fully agree though that .NET is far superior in terms of native interop.

This is not limited to native interop. At its design inception, C# was supposed to replace C++ components at MS. Then, in C# 2, a focus group including Don Syme if I'm not mistaken pushed for generics and other features. Someone posted a history bit here on HN.

This and influence from the projects like Midori (spans, struct improvements), and subsequent evolution (including the existence of Mono) and especially after it stopped being .NET Framework and became .NET resulted in a language that has much wider scope of application than most other GC-based languages, including Java, particularly around low-level tasks (which is also why it's popular in the gaming industry).

Unfortunately, the perception of "another Java" hurts the ecosystem and discourse significantly, as the language and the platform are very unlike this claim.

MAUI is not windows only. I have a MAUI app on my android phone. Cross-platform? yes. Rich? Now, I wouldn't call it that.

> - Android 5.0 (API 21) or higher is required.

> - iOS 11 or higher is required

> - macOS 11 or higher, using Mac Catalyst.

> - Windows 11 and Windows 10 version 1809 or higher, using Windows UI Library (WinUI) 3.

Okay, where's Linux? That's what Mono was originally made for and where Mono really shines.

Also, the development experience isn't great either:

> - If you are working on Linux, you can build and deploy Android apps only

> - You need a valid Visual Studio or IntelliCode subscription

The getting started guide only exists for Windows and macOS and the forum post announcing experimental Linux support is full of caveats.

I don't think you and I would agree on what "cross-platform" means, especially in the context of Mono being donated to Wine, which is a heavily linux-centric discussion topic.

> - You need a valid Visual Studio or IntelliCode subscription

You don't: https://marketplace.visualstudio.com/items?itemName=ms-dotne... (DevKit, which is the licensed one, is completely optional - it gives you VS-style solution explorer. You can already get it with e.g. F#'s Ionide that works for any .NET file in the solution, though I use neither)

Or https://github.com/razzmatazz/csharp-language-server with either Neovim or Emacs.

> Okay, where's Linux? That's what Mono was originally made for and where Mono really shines.

Regretfully, you have not read the rest of the discussion that talks about this a lot, so here it goes:

Uno: https://platform.uno/docs/articles/get-started-vscode.html?t...

(Uno has more involved setup and build than Avalonia but has way better mobile targeting, and casual reports indicate smaller memory footprint)

Avalonia: https://avaloniaui.net + https://marketplace.visualstudio.com/items?itemName=Avalonia...

    dotnet new --install Avalonia.Templates
    dotnet new avalonia.app
    dotnet run

Gir.Core (GTK4 and co., successor to GTK#): https://gircore.github.io/docs/use.html

ImGui with Silk.NET: https://github.com/dotnet/Silk.NET/blob/main/examples/CSharp...

Well, those sentences were quoted from Microsoft's own documentation...

Sure, you've shown that some tooling exists, but it's sadly not easy to discover or as well supported

You can install at the link below, and then making a project is just `dotnet new console` and run with `dotnet run`

https://learn.microsoft.com/en-us/dotnet/core/install/linux

This was the same year Antitrust came out: https://en.wikipedia.org/wiki/Antitrust_(film)

Any support for open source or cross-platform stuff was a bulwark against claims of monopoly abuse, but none of it worked well enough to be a true replacement. Mono worked for some purposes, but it was far from the first party support cross-platform .NET gets today. Nowadays it sounds like .NET Core + third-party GUI libraries is the way to go.

For reference for those unfamiliar with the terms:

.NET Core was the name given to the cross-platform fork of the .NET runtime.

It was forked out of .NET 4.x and dropped support for a lot of things in the first versions.

It ran on various distributions of Linux and MacOS.

At the same time there were forks of other libraries/frameworks in the .NET ecosystem to have 'Core' variants. Often these were dropping support for legacy parts of their code so that they could run on Core.

Later versions of .NET Core brought over support for a many of the things that had been dropped.

.NET Core and .NET had stand-alone versions until .NET Core was renamed to . NET and became .NET 5.

So, if you want to do the most modern cross-platform C# you would use .NET 9.

It is "Core" in a lineage sense, but there's no need to make that distinction any more. The term "Core" is out of date, because the experimental "Core" fork succeeded, and became the mainstream.

For what I do, it's not really "Windows development" in any meaningful way. It is business functionality with HTTP, message queues etc, developed on mostly Windows laptops, and deployed to mostly Linux instances on the cloud. Not that the host OS is something that we have to think about often.

For this, .NET 3.x "the full framework windows only version" services are regarded as very much legacy, and I wouldn't go near one without a plan to migrate to a modern .NET version.

However, YMMV and people are also making windows desktop apps and everything else.

I am told that the C# language has evolved faster and better than Java. Despite its origins in .NET 1.0 being basically a "Microsoft Java".

But paradoxically there is now more diversity of actively used languages that target the JVM. e.g. Kotlin, Scala, Clojure.

https://en.wikipedia.org/wiki/List_of_CLI_languages

https://en.wikipedia.org/wiki/List_of_JVM_languages

Quantity of languages might be less important than: how many needs are served by those languages, whether the ecosystem is dynamic enough to keep expanding served niches, and whether the culture and community is likely to produce language support for a niche that matters to you ever or on a realistic timeline. The JVM does appear to have a lot more niches covered, but you can still do all the things those languages do in what's available for the CLI.

I don't know much about the current state of CLI and .NET beyond what I've read here, but it sounds like it's dynamic enough to keep expanding. I also don't know enough about the long tail of niche languages supported by each to know which direction they're headed.

That's the situation with the tools used for music production. In theory, any DAW (Digital Audio Workstation) can make any kind of music. In practice, they all move toward different kinds of music, and you'll run into increasing friction as you do weirder or more complex stuff if you pick the wrong DAW. Cubase can do electronic music, but you're better off with FL Studio or Live. Live and FL Studio can do orchestral, but you're better off with Cubase.

And I'd guess there's a similar dynamic with CLI and JVM and the languages that target them.

They've now abandoned that strategy, and instead they use it as a way to maintain lock-in at the IAAS/PAAS level (Azure).

> It was forked out of .NET 4.x and dropped support for a lot of things in the first versions.

>An early name for the .NET platform, back when it was envisioned as a successor to the COM platform (hence, "COM+"). Used in various places in the CLR infrastructure, most prominently as a common prefix for the names of internal configuration settings. Note that this is different from the product that eventually ended up being named COM+.

For example, see the top comment in https://github.com/dotnet/runtime/blob/main/src/coreclr/vm/o...

I love .NET. It’s a great stack, especially for backend web apps. Blazor is a great SPA framework too. But I loathe how Microsoft continue to handle just about everything that isn’t the framework and C# / F#. It’s laughable.

.NET Standard includes various versions of things that MS doesn't even touch.

I stopped doing .NET stuff before .NET 5 so I'm not hugely up to date with the latest shenanigans.

It’s just funny for newcomers to peel back the onion more. Writing a source generator? Target .NET standard 2.0 (not even 2.1) for a whole host of reasons.

Visual Basic .net ! What ?

But for the last 20-ish years it's really only been applied to things related to the .NET Framework.

So, yes - Visual Basic.NET is a language - it's the language that replaced Visual Basic 6. It compiles to the Intermediate Language (IL) that the Common Language Runtime (CLR) executes. There are other languages that compile to IL, too like C#, F#.

The .NET Framework is really a bunch of libraries and tools that are packaged together.

The .NET Standard is a standard that allows you to build a library to a known set of supported libraries and IL / CLR features.

So, yes, depending on which specific part you're referring to - it's all of those.

everything is .net, azure, 365, now also copilot.

https://snltranscripts.jt.org/75/75ishimmer.phtml

I’m just sad the video is not readily available because the facial expressions enhance the spot-on vocal inflections.

We do have the vocal inflections: https://m.youtube.com/watch?v=wPO8PqHGWFU

The current release is .NET 8

.NET 9 is about 3 months away from the usual November release.

A factoid that's shared sometimes (no idea if true) is that Microsoft now employs more Linux kernel engineers than Windows kernel engineers due to Azure.

The Microsoft of the Halloween Documents[0] is a different Microsoft from the one we see today that understands open source as something good rather than as a threat, and it started with Microsoft being forced to play nice.

"The cloud" as we understand it didn't exist yet.

[0] https://en.wikipedia.org/wiki/Halloween_documents

Strange times.

Bona fides: I have used GCP for 3 years, AWS for 3 years, and Azure for ~ 1 year. As well as the more "bare-metal" types of cloud providers like Linode/Akamai, and Vultr -- all the latter of which are great for self managing your infra.

I also really find the ability to spin up Windows Server and Windows 10/11 etc super useful for builds, testing, Hyper-V.

I really like Azure for huge projects with many moving parts.

Is "historical context" not as clear as I thought? You're the second person to challenge this by pointing out the current situation when I'm talking about how we got here.

Microsoft Azure was first released on February 1, 2010

Microsoft released .NET Core 1.0 on June 27, 2016

It's (of course) not portable

[1] https://avaloniaui.net/ [2] https://platform.uno/

My point is about running existing applications on Linux, there are still issues with running .Net GUI stuff under wine and Mono was not a perfect implementation.

I read in other comments that the newer .Net cross platform stuff is not a replacement for Mono for running this old applications. (nobody will rewrite them to use the current GUI stuff from MS since are old apps)

If I was building a cross platform native app with .NET I'd probably use Avalonia right now.

I think not supporting Linux was a tactical error, though. Some people will put up with a lot for Linux GUI support, and some of those people are the types who can resolve problems with your half-baked GUzi framework.

Support reasons. Still isn't the year of Linux Desktop.

Were I live and work (IT and consulting in central south-east Norway) it has been the year of the Linux Desktop on and off since 2009.

That was the first time I worked full time at a place that deployed Linux for everyone and everything that didn't have a verified reason for needing Windows.

I think we had one 3rd party trading software running on a Windows machine and maybe the CEO and someone in accounting got Windows.

Everyone else was upgraded to Linux and it worked beatifully. It was my job to support the sales department with desktop related issues and it was absolutely no problem to do it while also being a productive developer.

Since then I have not worked on a place that required Linux, but I think most of the places I have worked on since has had Linux as an option as long as you supported it yourself, and some places also have been very active writing how-tos and working with me to troubleshoot issues that were related to Linux, since many of them were also Linux users.

At the moment I use Mac, but at my current job I'm also allowed to use Linux.

Sure, Microsoft could pay more employees to work on it faster, but Linux loves and prefers open source from Linux devs "untainted by Microsoft", right?

Huh

Alternatively, just because you're on .NET doesn't mean you need to use Microsoft sanctioned UI toolkits, just as C++ has no "official" UI toolkit. You're free to pick up some GTK or Qt bindings if you want a native feeling and your application is already architectures correctly. Alternatively, throw Imgui at it if you just need dev tooling, or maybe try other cross platform toolkits in the ecosystem like Avalonia or Uno

Works better in proton from my experience though, but I think that is due to making unity games run better

Sadly some Java tools stopped working if you run latest Java runtime because for some reason some crap was removed from Java and nobody made some easy way to add them back with soem package install.

Also very easy to throw something together on top of SDL2 with Silk.NET.

Practically speaking it is in a much better place than many languages considered by parts of Linux community to be more """linux-oriented""".

https://dotnet.microsoft.com/en-us/apps/maui

"Build native, cross-platform desktop and mobile apps all in one framework."

I know my buddy uses it to write Android apps on his Mac that interface to an ASP.NET Core web site.

I'd say it's the simplest and quickest way to go if you need to bang out a quickie app for Windows only.

https://learn.microsoft.com/en-us/dotnet/desktop/winforms/?v...

https://github.com/dotnet/runtime/

https://github.com/dotnet/roslyn

Will it be cross-platform?

The UI isn't native, is a Skia canvass with drawn controls. But it'll work on basically every OS and it's pretty good.

Also, you're not writing JavaScript, so that's a win any day in my book.

And unfortunately, the only stench I can't stand more than Google's is Microsoft's.

Following buzz I started to do a prototype with Flutter and stopped after a few days as I found out that most of the open source controls I was using had bugs on Windows Desktop. Then I moved to MAUI and discovered that in order to have some decent Rich Text support my only option was Blazor Hybdrid. Nedless to say I found bugs that prevented my prototype to work correctly. Then I moved to UNO and found that it doesn't have full Rich text format support. I was able to find some .NET open source libraries for doing text layout on Skia and with that I was able to find a partial solution that was however pretty complicated. Out of curiosity I investigated Avalonia and found that everything that I needed had full support. Being fluent in WFP I built the prototype in 3 days and I never looked back.

Your experience might vary depending on your fluency of WFP but I found that, considering Windows Desktop as a target platform, Flutter and MAUI are absolutely the worst options. In my opinion Uno is better than Avalonia when considering web application support but Avalonia has more coverage of the WPF api with respect to what Uno does for WinUi. And for sure marketing is the worst part of Avalonia while it is the BEST for MAUI and Flutter.

yes

https://avaloniaui.net/

BUT That's now officially unsupported as all of Xamarin Forms is no longer supported and the MAUI replacement doesn't cover Linux nor does that look likely (MAUI is mired deep in problems due over-ambition, failure to resource and it seems a significant push in MS to use MAUI Hybrid aka web UIs within native apps).

It is like the Web folks, that don't get anything else, are now pushing where .NET goes, mostly since .NET is now under Azure org chart.

I have done Web and native since "forever", not everything has to be for everything.

https://www.electronjs.org/blog/webview2/

When Microsoft teams behave as such, why should we keep paying attention?

For native Windows, Forms, WPF, and even MFC is way better in VS tooling than WinUI C++.

  - OS X: MonoMac or net6.0-
  - Linux: GTK+ 
  - Windows: Windows Forms (using GDI or Direct2D) or WPF

  - Gtk3: https://github.com/GtkSharp/GtkSharp
  - Gtk4: https://github.com/gircore/gir.core

There's the first party MAUI which is an updated version of Xamarin Forms. The two best-known third-party implementations are AvaloniaUI and Uno. I prefer Uno, it has more cross-platform targets.

https://docs.tryphotino.io/Overview

Which lets you run Blazor (web framework) like a desktop UI across all major desktop platforms. Microsoft has MAUI/Blazor as a thing, but only targets Mac and Windows ATM, so Photino bridges the gap for Linux.

Photino lets you use anything other than just .NET but has pretty decent .NET support.

https://platform.uno/

If you cared about disk or memory usage you wouldn’t use electron, anyway.

History here https://en.wikipedia.org/wiki/.NET

.NET Core 1.0 (2016) was the first cross platform prototype. It got good in a release in 2018 or 2019, I even forgot which now. And took over steadily after that.

We don't even think about it any more. "which OS is the prod env on" isn't a factor that causes any support worries at all.

Getting set up would start at https://dot.net/

And the download page, which should show you content for your current OS https://dotnet.microsoft.com/en-us/download

But also other targets are here https://dotnet.microsoft.com/en-us/download/dotnet/8.0

You'll want the latest SDK 8.0.x

I would say I’m not ‘new’ and even developed .net 4.5 for a number of years. I’m just as stumped by the naming mess that Microsoft made across the board in that space.

Edit: I say 4.5 because I mean the original thick .net which is not dotnet core, which I think is the way to differentiate between versions, but also all the sub libraries like the orm were iirc named the same but did different things.

They should have rebadged everything with a new name that didn’t involve a word that is fairly painful to google (‘core’) can be used in development as well as the name of a framework.

So let's say you google how to do something and the result could be:

  - .NET Framework
  - .NET core 1
  - .NET core 2
  - .NET core 2.1
  - .NET core 3
  - .NET 5+

On stackoverflow, answers sometimes include all versions varieties.

For a historic summary of why it used to be a confusing situation (up until maybe 2020), see https://two-wrongs.com/dotnet-on-non-windows-platforms-brief...

That also has some background on why the Mono project found itself in a weird spot.

https://time.graphics/line/291016

This is quite overwhelming, but it can still be useful when reading an article about .NET that is either older or refers to history as you can quickly see where in time it is located.

Not really. It's legacy cruft all the way down.

But the good news is that if you stay on the beaten path, using the latest SDK and targeting the latest Runtime, everything Just WorksTM.

currently debian has a mono package but no dotnet-core package. i'm not sure why this is; usually when debian lacks a popular nominally open-source package like this, it's either because it fails to build from source, or because it has some kind of tricky licensing pitfall that most people haven't noticed, but diligent debian developers have

does anyone know why this problem exists for dotnet-core?

also, does dotnet-core have a reasonable aot story for things like esp32 and ch32v003?

Fedora [2], Ubuntu [3], and FreeBSD [4] build .NET from source themselves. A lot of work has been done to make it possible to build .NET from source [5] without closed source components, so it might just be a matter of someone being motivated to create the package for Debian.

[1]: https://learn.microsoft.com/en-us/dotnet/core/install/linux-...

[2]: https://src.fedoraproject.org/rpms/dotnet8.0

[3]: https://launchpad.net/ubuntu/+source/dotnet8

[4]: https://github.com/freebsd/freebsd-ports/tree/main/lang/dotn...

[5]: https://github.com/dotnet/source-build

I think telemetry collection alone should be a good reason for Debian to consider repackaging it. I don’t want telemetry to be collected on my GNU/Linux machine, thanks Microsoft, but you already have so much telemetry from my Windows machine, please leave my other machines alone.

https://dotnet.microsoft.com/en-us/platform/telemetry

https://learn.microsoft.com/en-us/dotnet/core/tools/telemetr...

https://github.com/dotnet/sdk/tree/main/src/Cli/dotnet/Telem...

In any case, Debian would use https://github.com/dotnet/source-build and dotnet/dotnet, and could easily include the argument or a patch for this. It’s unlikely to be an issue. My bet it was not in Debian because there was no one to take initiative yet or there was but that person has faced a backlash by people in Debian who are similar to vocal minority here that posts FUD because of their little personal crusade.

i think the links you provide make it clear that the criticism is not unfounded

as for building from source, i see, thanks! or maybe it's unresolved legal concerns? nobody so far in this thread has known of any, though

https://bugs.debian.org/cgi-bin/%3Ca%20href=%22bugreport.cgi...

So far no one has mentioned licensing being an issue.

that seems to be from only a few weeks ago though

it doesn't seem to have come up on debian-legal in the last year or so https://lists.debian.org/debian-legal/ but debian-legal is also kind of a shadow of its former self

Does Debian require packages to work on all of its architectures? If so, that could be the issue. .NET Core only supports x86, x64, and Arm64 (I think Arm32 has been discontinued and RISC-V is experimental at this point).

It's possible that they object to .NET Core having certain license restrictions on the Windows port (https://github.com/dotnet/core/blob/main/license-information...). .NET Core is mostly MIT or Apache licensed, but the Windows SDK has some additional terms. Skimming the third party licenses, that doesn't seem like an issue (mostly MIT/BSD/Apache or similar).

I think the licensing situation is an interesting question: if you have software that's 100% open source when compiled for your OS, but requires non-free stuff to run on Windows, is it ok to include in Debian? It looks like none of the non-free stuff (like WPF) gets distributed with the non-Windows SDK builds. Binaries created from your code only depend on MIT-licensed stuff on macOS and Linux, but might depend on something closed-source when targeting Windows - though it looks like almost all of that stuff is either WPF (so you wouldn't be able to develop on Linux/Mac anyway since those libraries wouldn't be in the SDK on those platforms) or were removed as a runtime dependency in .NET 7. It looks like `Microsoft.DiaSymReader.Native` might be the only thing left. Maybe that's what is holding it back?

> also, does dotnet-core have a reasonable aot story for things like esp32 and ch32v003?

"Reasonable" can be a lot of things to a lot of different people. People have been working on RISC-V support. Samsung seems interested in it. But I probably wouldn't recommend it at the moment - and Mono doesn't really have RISC-V support either.

debian doesn't require packages to work on all of its architectures. luajit, for example, has not been ported to riscv64, mips64el, or ppc64el https://packages.debian.org/sid/luajit, though lua5.1 is https://packages.debian.org/sid/lua5.1. what the debian policy manual says about architecture-specific packages seems to be https://www.debian.org/doc/debian-policy/ch-controlfields.ht...:

> Specifying a specific list of architectures indicates that the source will build an architecture-dependent package only on architectures included in the list. Specifying a list of architecture wildcards indicates that the source will build an architecture-dependent package on only those architectures that match any of the specified architecture wildcards. Specifying a list of architectures or architecture wildcards other than any is for the minority of cases where a program is not portable or is not useful on some architectures. Where possible, the program should be made portable instead.

i don't think the license you link to would be a problem in itself, because it only applies to certain files which are not useful for running dotnet-core on debian anyway. debian has lots of packages from which non-free-software files have been removed. i don't know anything about diasymreader?

with respect to esp32 and ch32v003, what i meant to point to was not the risc-v architecture (some esp32s are tensilica!) but the limited memory space; jit compilation is not a good fit for 2 kibibytes of ram or even 520 kilobytes of ram

.NET 9.0 preview still includes ARMv7 builds for Linux: one based on glibc library, another one for Alpine.

They could get one of their people to become Debian maintainer.

Perhaps the Debian project would force a .NET package to come with telemetry disabled by default, but for as long as said employee can abide by the rules of Debian, I don't really see any reason it can't be done.

and, correct me if i'm wrong here, but doesn't c# allow you to statically allocate structs just as much as c does? i'd think you'd be able to avoid garbage collection about as much as you want, but i've never written much beyond 'hello, world' in c#

Otherwise, statics are placed in a static values array "rooted" by a respective assembly. I believe each value will be contained by a respective box if it's not an object. This will be usually located in Gen2 GC heap. My memory is a bit hazy on this specific part.

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 Meadow: 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 with other GC-based alternatives.

https://www.nanoframework.net/

Does the wine project have the resources and knowledge to maintain it?

Or is it just so that microsoft can say they aren't the ones discontinuing it?

But he was in love with COM/DCOM, registry, and many other things that MS shipped. Some of these things made Gnome much slower than it could be.

GitHub Actions are a major part of that. Codespaces, a solution for Mac CI, that you automate so much, store secrets, drive not CI but CD straight from GitHub now, etc. It's evolved a ton. Then you have the other things they are doing as company with copilot and vscode (and formerly atom).

Sure, code search is only moderately better, and maybe some of the core git features aren't getting as much razzle-dazzle in the UI, but it's evolved a ton.

Just hire someone who worked for Google and copy their internal code search.

(Preview available here: https://source.chromium.org/)

Technical caveat: To work effectively, it needs to be able to compile (parse into an AST) the code, which for many GitHub projects is challenging. I'd bet they could easily get to 80% compilation rate though and then use dumb text search on the rest.

Honestly, we should probably abandon the hope that we will ever get full universal adoption. It stinks even worse with the half-adoption state we are in now, with some apps writing to those directories and other apps not. If it wasn't for arch Linux folks trying to drive apps to adopt it more, I don't think it would be. Hell, default Debian/Ubuntu still doesn't set XDG_* directory ENVs by default (some flavors do), and some apps ignore the prescribed "if not set, use this default" nonsense in the spec and do what they have always done because it doesn't break compatibility for users.

Part of the spec stinks, too, like the spit between cache/config/data config where the spec has no written rules specified on when anything is expected to be cleaned up and when or what can or should be backed up by the user.

Let's move to containerizing most apps, putting everything in little jails so we don't have to deal with where they want to write to. They can have their own consistent and expected behaviors on their own island. Snapcraft, flatpack, or any of a bunch of other solutions are already available to solve this problem. Don't have to worry about what some app left behind or wrote to your system when it's all contained.

You are supposed to leave them unset if they match the defaults.

Programs ignoring the spec is another matter and should be fixed in those programs not by needlessly bloating the environment of every process with meaningless data.

Things like .git and .ssh not are not meaningless data even though they are not in ~/.config/ssh/ or ~/.local/shared/git.

It stinks about half as much as before.

> Part of the spec stinks, too, like the spit between cache/config/data config where the spec has no written rules specified on when anything is expected to be cleaned up and when or what can or should be backed up by the user.

Caches don't have to be backed up and can be deleted if you need space. Most people will want to back up configs. What other data should be backed up is a question different people will answer differently. And containers don't solve this.

Otherwise, you're directly heading for a nasty surprise at the worst moment.

Actually AppData can get a bit polluted too.

Typical of our society, we want to make everything someone else's problem.

I guess we deserve some of the SaaS enshittification and it's spending obesity ;-)

Yes, this.

> Typical of our society, we want to make everything someone else's problem.

I don't think that's a fair analogy.

It's more like moving junk from the living room to the attic. I'd prefer to have a clean living room and a messy attic.

> Yes, this.

Like "My Documents" (or "Documents" nowadays)? Now that's some dumping ground.

~/Library also isn't something that is used to be; it was good idea, but mostly ignored. Basically similar idea as XDG_(CONFIG|CACHE|DATA)_DIR.

What's worst, is that many projects ignore any effort to move them to XDG schema. They take the approach, that they always did it this way, it works, so why changing it.

Dot files in my homedir on Sonoma machine:

    .CFUserTextEncoding
    .DS_Store
    .Trash/
    .Xauthority
    .amt
    .android/
    .anyconnect
    .bash_history
    .cache/
    .cargo/
    .config/
    .cups/
    .degit/
    .deno/
    .docker/
    .eclipse/
    .emacs.d/
    .gitconfig
    .gitignore_global
    .grass7/
    .hex/
    .homeassistant/
    .ipython/
    .java.login.config
    .jupyter/
    .kube/
    .lemminx/
    .lesshst
    .local/
    .matplotlib/
    .mix/
    .mume/
    .node/
    .notable.json
    .npm/
    .nvm/
    .oh-my-zsh/
    .oracle_jre_usage/
    .pip/
    .profile
    .psql_history
    .python_history
    .rest-client/
    .rustup/
    .sqitch/
    .ssh/
    .subversion/
    .swiftpm/
    .thumbnails/
    .viminfo
    .vscode/
    .wget-hsts
    .wine/
    .yarn/
    .yarnrc
    .zcompdump
    .zsh_history
    .zsh_sessions/
    .zshenv
    .zshrc