Ten languages, one window: what you install

October 23, 2026 · Neper binaries measured with emit-executable; every other number is cited below

Putting one window on screen on Windows, Linux and macOS takes very different amounts of software depending on the language. We read the official install guides for ten popular desktop languages and set them beside Neper. Neper wins on three things: one install builds programs for every desktop OS from a single machine, the user installs nothing to run them, and the window is 2.7 MiB with no runtime inside it.

Where Neper wins

The scorecard

One row per stack. "C++ toolchain" means a C or C++ compiler or Visual Studio workload somewhere on the way to an executable. Details and sources for each language are further down.

Sizes for the ten others are reported or documented, for different kinds of app. Only the Neper figure is ours.

How big is the smallest app?

Tauri's own documentation claims under 0.6 MB, without counting the system webview. Neper's number is the whole window stack: renderer and widget runtime included.

How we picked, and what we counted

No 2025 or 2026 survey measures which language people use for desktop. We took language usage from the Stack Overflow 2025 survey and desktop frameworks from its 2024 edition, the latest that asks: .NET 25.2%, Flutter 9.4%, Qt 7.3%, Electron 6.5%, SwiftUI 4.3%, Tauri 2.4%. Kotlin is the weakest pick, since Compose Multiplatform is not in that list. Delphi (2.5% usage) is the likely swap for someone ranking desktop only; we could not verify that, so we kept the list.

Each language in detail

Open a language for what it needs to build, what the user needs to run, and the sources behind the scorecard.

Two signing facts apply to every language. Distributing a Mac app outside the App Store means notarization, which needs a Developer ID certificate and the $99-a-year Apple Developer Program. Windows signing is optional, but unsigned apps trigger warnings.

What the ten have in common

Neper

Neper's compiler writes the executable itself, including the PE, ELF and Mach-O headers, the linker and the ad-hoc macOS code signature, so a program does not go through a C++ compiler, an SDK or a system linker. The compiler is written in Neper. Getting the first compiler means building from source, and that is the one place a C toolchain appears:

$ scripts/build-selfhost.sh   # Linux, macOS; scripts/build-selfhost.ps1 on Windows
# a throwaway C99 bootstrap (cl, or cc) builds the compiler once;
# the compiler then builds itself and prints its own path

After that the C compiler is not used again. We built the repository's smallest window program, ui_app (a 200 by 120 box, built with the real window, renderer and widget runtime), and a console hello, from one Windows machine with the self-hosted compiler:

$ neper-self emit-executable tests/selfhost/fixtures/link/ui_app/src/main.e . x64 windows hello-win.exe --release
$ neper-self emit-executable tests/selfhost/fixtures/link/ui_app/src/main.e . x64 linux   hello-linux --release
$ neper-self emit-executable tests/selfhost/fixtures/link/ui_app/src/main.e . aarch64 macos hello-macos --release
$ neper-self emit-executable examples/hello.e . x64 windows h.exe --release   # also: x64 linux, aarch64 linux, x64 macos, aarch64 macos

What that means for the build and the run:

• To build: the Neper compiler and a text editor. No SDK, no IDE, no installer download, and no second language's toolchain once you have the compiler.
• To run on Windows: Windows. The program calls the system's own window functions.
• To run on Linux: a display with an X11 socket. Neper speaks the X11 protocol itself, with no GTK or Qt. XWayland works; a Wayland-only session does not.
• To run on macOS: macOS. The program uses the Objective-C runtime, CoreFoundation and CoreGraphics that ship with the system.

The limits of those wins

• No Wayland. A Linux session without an X server cannot open a window. window_open answers Unsupported.
• macOS builds from Windows, but we have not run those binaries on a Mac. The x64 and arm64 executables are real Mach-O files, ad-hoc signed by the compiler as Apple Silicon requires. The repository's runner checks (a macos-14 machine, x64 under Rosetta) cover the console and system-library side; the window program is built here but not confirmed on a Mac. There are no .app bundles, no Developer ID signing and no notarization, so a Mac app for other people still needs an Apple Developer account and a manual bundle step, in any language.
• No packaging story yet. There is no MSI, DMG or deb builder, no installer, and no package-manager release of the compiler. Today you clone the repository and run the build script.
• Windows still needs a C toolchain once. The bootstrap builds with cl, so the first compiler on Windows needs the MSVC build tools. This is the same prerequisite as Rust, Flutter and C++ have, paid once instead of per project.
• No designer, and a young ecosystem. There is no visual designer, no third-party control market and no Stack Overflow answer history. Every library in the box is Neper's own.
• This is not a like-for-like size test. The other ten rows are sourced reports of different app shapes (a console app, a template, a forum post). Only the Neper rows are ours. Build the same hello window in each language and measure it before quoting any ratio.

Targets we plan next

What exists today is Windows, Linux and macOS on x64 and arm64. These are planned, and none of them exists yet:

FreeBSD is evaluated as a candidate and not scheduled. Each of these is a distinct target with its own binary rules, not a relabelled Linux or macOS build, and we will report them here as we measure them, not before.

Sources

• Language and framework usage: Stack Overflow 2025 and 2024; JetBrains .NET 2025.
• .NET: downloads, Native AOT, MAUI platforms, Visual Studio 2026 requirements.
• C++: Qt on Windows, Qt on macOS, Qt deployment, VC++ redistributables.
• Java and Kotlin: jpackage, Compose distribution.
• Web stacks: Tauri prerequisites, Tauri Windows installer, Electron 45 assets, framework size benchmark.
• Others: PyInstaller, Flutter on Windows, Flutter on Linux, rustup on Windows, Fyne, Swift on Windows, Apple Developer Program.
• Neper's X11 and macOS window code: lib/e/os.linux.e, lib/e/os.macos.e; the Mach-O linker and its ad-hoc signature: src/link_macho.e; the build scripts: scripts/build-selfhost.*.

Versions and sizes were read on October 23, 2026 and drift. If a cell here is wrong or out of date, we want to know.