Skip to content
Published on

2026 Systems Languages and Package Managers - Zig, C++26, Carbon, Mojo, Swift Server, Kotlin, C# .NET 9, uv, pnpm, Bun Deep Dive

🇰🇷KO🇺🇸EN🇯🇵JA
Split View필사 모드
Authors

The 2026 systems language landscape has reached an inflection point. Zig 0.14 stabilized incremental compilation and its new build system, C++26 absorbed P2900 contracts and P2300 std::execution into the standard, and Mojo 1.x has reached production maturity as an MLIR-backed Python superset that can also author GPU kernels. Swift gained a real foothold as a Linux server language through Vapor and Hummingbird, and Kotlin lightened its server runtime via Ktor 3 and GraalVM native images. C# 13/.NET 9 became container-friendly through native AOT and primary constructors. The package manager scene mirrors this: uv is replacing pip and Poetry in practice, while pnpm 10 and Bun have split the npm ecosystem.

The Systems Language Map at a Glance

As of May 2026, the simplified picture is this. C and C++ still dominate OS kernels, game engines, and databases, but Rust, Zig, Carbon, and Mojo are penetrating specific domains. On the JVM, Kotlin is displacing Java in both Spring and Ktor, while Scala 3 and Clojure 1.13 hang on in data and finance. .NET 9 now achieves Go-like cold-start times and memory footprints for cloud-native workloads.

Zig 0.14 - Incremental Compilation and the Build System

Zig 0.14 graduated incremental compilation from beta to a stable workflow, redesigned its async model, and integrated a package manager (zig fetch) into the build.zig build system. comptime remains Zig's core differentiator.

const std = @import("std");

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();

    var list = std.ArrayList(u32).init(allocator);
    defer list.deinit();

    try list.appendSlice(&[_]u32{ 1, 2, 3, 4, 5 });

    var sum: u64 = 0;
    for (list.items) |x| sum += x;

    std.debug.print("sum = {d}\n", .{sum});
}

comptime generics deliver safe abstraction without macros. The comptime keyword marks code that runs at compile time, with types themselves treated as first-class values.

C++26 - Contracts and std::execution

C++26 landed P2900 contracts (pre/post-conditions, assertions) and P2300 sender/receiver (std::execution) in the ISO standard. A subset of static reflection also shipped, dramatically simplifying compile-time metaprogramming.

#include <execution>
#include <expected>
#include <print>

std::expected<int, std::string> parse_port(std::string_view s) {
    int port = 0;
    auto [ptr, ec] = std::from_chars(s.data(), s.data() + s.size(), port);
    if (ec != std::errc{}) return std::unexpected("invalid number");
    if (port < 1 || port > 65535) return std::unexpected("out of range");
    return port;
}

int main() {
    auto result = parse_port("8080")
        .transform([](int p) { return p + 1000; });
    if (result) std::println("port = {}", *result);
    else std::println("error: {}", result.error());
}

C++23 features like std::expected<T, E> and std::print are now stable across LLVM/Clang, GCC 14+, and MSVC 2024+, and deducing this (Self) has simplified CRTP-style patterns.

Carbon - Google's "C++ Successor" Experiment

Carbon remains experimental in 2026, with toolchain features partially working in 0.x. Its goal is two-way interop with existing C++ code while offering a safer, more modern syntax. Unlike Rust, Carbon does not adopt a borrow checker; instead it focuses on generics, interfaces, and ADTs.

package Sample api;

fn Fibonacci(n: i32) -> i32 {
  if (n < 2) { return n; }
  return Fibonacci(n - 1) + Fibonacci(n - 2);
}

fn Main() -> i32 {
  Core.Print("fib(10) = {0}", Fibonacci(10));
  return 0;
}

Carbon today is less about mass adoption and more about charting "where C++ should evolve."

Mojo 1.x - Python Superset on MLIR

Modular's Mojo released its 1.x line with broader Python superset compatibility. Built on MLIR, it can author CPU SIMD code and GPU kernels in the same language.

from tensor import Tensor

fn dot_product(a: Tensor[DType.float32], b: Tensor[DType.float32]) -> Float32:
    var acc: Float32 = 0.0
    for i in range(a.num_elements()):
        acc += a[i] * b[i]
    return acc

fn main():
    var x = Tensor[DType.float32](1024)
    var y = Tensor[DType.float32](1024)
    print(dot_product(x, y))

Mojo can import existing Python directly, but functions defined with fn get static types and automatic SIMD optimization.

Swift 6 Server - Vapor 4 and Hummingbird 2

Swift 6 enforces strict concurrency by default, and Linux builds plus static linking are now solid. Vapor 4 and Hummingbird 2 are both SwiftNIO-based HTTP server frameworks.

import Vapor

let app = try Application(.detect())
defer { app.shutdown() }

app.get("hello", ":name") { req async throws -> String in
    let name = req.parameters.get("name") ?? "world"
    return "Hello, \(name)!"
}

try await app.execute()

Mercari is known to run some backend services on Swift server, and Apple, through swift.org/server, has been steadily evolving the standard library and SwiftPM.

Kotlin Server - Ktor 3 and Spring Boot 3 Native

Kotlin 2.1 makes the K2 compiler the default and strengthens multiplatform stability. Ktor 3 offers a coroutine-based lightweight HTTP server, and Spring Boot 3 builds to sub-50 MB static binaries under GraalVM Native Image.

import io.ktor.server.application.*
import io.ktor.server.engine.*
import io.ktor.server.netty.*
import io.ktor.server.response.*
import io.ktor.server.routing.*

fun main() {
    embeddedServer(Netty, port = 8080) {
        routing {
            get("/health") { call.respondText("ok") }
            get("/users/{id}") {
                val id = call.parameters["id"] ?: "0"
                call.respondText("user $id")
            }
        }
    }.start(wait = true)
}

Toss uses Spring Boot plus Kotlin as its primary backend stack, Coupang migrated incrementally from Java to Kotlin, and LINE Yahoo has aggressively adopted Kotlin for messaging and ad servers.

C# 13 / .NET 9 - Native AOT and Primary Constructors

.NET 9 has made native AOT production-ready, and primary constructors plus collection expressions are now mainstream. ASP.NET Core minimal APIs start faster than Spring.

var builder = WebApplication.CreateSlimBuilder(args);
builder.Services.AddAuthorization();

var app = builder.Build();
app.MapGet("/health", () => Results.Ok(new { status = "ok" }));
app.MapGet("/users/{id:int}", (int id) =>
    Results.Ok(new { id, name = $"user{id}" }));

app.Run();

CreateSlimBuilder reduces reflection for AOT-friendly builds, and with PublishAot=true you get a single ~10 MB executable.

JVM Language Ecosystem - Scala 3, Clojure 1.13, Groovy 4

Scala 3 has settled into indentation-based syntax with union types, and after Akka's license change Pekko became the de facto successor. Clojure 1.13 improved the build experience via deps.edn and tools.build, and its REPL-first workflow is still uniquely powerful. Groovy 4 survives mainly as the Gradle DSL, with little new adoption.

Crystal, Nim, V - Small Compiled Languages

Crystal 1.13 pairs Ruby-like syntax with a static type system and an LLVM backend. Nim 2.x combines Python-like syntax with ARC/ORC GC and rich metaprogramming. V (Vlang) emphasizes fast compilation and simplicity but has a smaller ecosystem. All three are pragmatic for small CLI tools and embedded services.

Bazel 8, Buck2, Pants - Monorepo Build Systems

Bazel 8 makes bzlmod the default, simplifying external dependency management. Buck2 is Meta's Rust rewrite with excellent remote execution performance. Pants 2.20 broadly supports Python/Java/Go and is popular at digital advertising and fintech companies.

# BUILD file (Bazel)
load("@rules_rust//rust:defs.bzl", "rust_binary", "rust_library")

rust_library(
    name = "core",
    srcs = glob(["src/lib.rs", "src/**/*.rs"]),
    edition = "2024",
)

rust_binary(
    name = "server",
    srcs = ["src/main.rs"],
    deps = [":core"],
    edition = "2024",
)

Gradle 9 and Mill - Two JVM Build Branches

Gradle 9 formally recommends the Kotlin DSL and stabilizes the configuration cache. Mill is a new Scala-based JVM build tool that mixes a Bazel-like task graph with Maven compatibility.

plugins {
    kotlin("jvm") version "2.1.0"
    application
}

repositories { mavenCentral() }

dependencies {
    implementation("io.ktor:ktor-server-core:3.0.0")
    implementation("io.ktor:ktor-server-netty:3.0.0")
    testImplementation(kotlin("test"))
}

application {
    mainClass.set("com.example.MainKt")
}

uv - The New Python Package Manager Standard

Astral's uv, written in Rust, unifies pip, pip-tools, Poetry, and virtualenv. In 2026 it is effectively the default for new Python projects. Dependency resolution is 10-100x faster than pip, and it ships as a single static binary.

[project]
name = "my-app"
version = "0.1.0"
requires-python = ">=3.12"
dependencies = [
    "fastapi>=0.115",
    "pydantic>=2.9",
    "httpx>=0.27",
]

[dependency-groups]
dev = [
    "pytest>=8.3",
    "ruff>=0.7",
    "mypy>=1.13",
]

[tool.uv]
managed = true

A common Poetry-to-uv migration pattern is to run poetry export for a requirements file and then add the entries back with uv add.

pnpm 10, Yarn 5 (Berry), Bun - npm Ecosystem Split

pnpm 10 has become the de facto monorepo standard with its disk-efficient content-addressable store and workspace tooling. Bun bundles its own package manager (bun install), bundler, and runtime into a single binary. Yarn 5 (Berry) keeps pushing Plug'n'Play, removing node_modules entirely.

# pnpm-workspace.yaml
packages:
  - 'apps/*'
  - 'packages/*'
catalog:
  react: ^19.0.0
  typescript: ^5.7.0

Benchmark order is typically Bun > pnpm > Yarn Berry > npm for install speed, though monorepo size and cache state matter.

Bun 1.x - Unified JavaScript Runtime

Bun 1.x ships with Node compatibility and packages bun install, bun test, bun build, and bun run into a single binary. It bundles faster than esbuild in most cases and natively executes TypeScript and JSX.

# Bootstrap a new project
bun init -y

# Add dependencies
bun add hono zod
bun add -d @types/node

# Run a server with hot reload
bun --hot src/server.ts

# Build a standalone binary
bun build --compile --target=bun-linux-x64 src/server.ts --outfile server

Pixi - Polyglot Scientific Computing Package Manager

Prefix.dev's Pixi builds on the Conda ecosystem but adds Cargo-style lockfiles and a task runner. It can pin Python, R, C++, and CUDA dependencies in a single manifest, which is why it is spreading quickly in ML and scientific computing.

[project]
name = "ml-experiment"
channels = ["conda-forge", "pytorch", "nvidia"]
platforms = ["linux-64", "osx-arm64"]

[dependencies]
python = ">=3.12,<3.13"
pytorch = ">=2.5"
numpy = ">=2.0"

[tasks]
train = "python train.py"
eval = "python eval.py --checkpoint=last"

Nix and Nix Flakes - Reproducible Builds

Nix is a functional package manager that pins dependencies and builds via content hashes. Flakes are the modern interface that makes inputs and outputs explicit.

{
  description = "Polyglot dev shell";
  inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
  outputs = { self, nixpkgs }:
  let
    system = "x86_64-linux";
    pkgs = import nixpkgs { inherit system; };
  in {
    devShells.${system}.default = pkgs.mkShell {
      packages = with pkgs; [ zig rustup nodejs_22 bun uv go_1_23 ];
    };
  };
}

NixOS still has a steep learning curve, but the upside of one nix develop giving the whole team an identical environment is large.

Conan, vcpkg - C/C++ Package Managers

Conan 2.x and Microsoft's vcpkg are the two main pillars of C/C++ dependency management. Conan offers fine-grained ABI tracking through profiles, while vcpkg integrates naturally with manifest mode and CMake. Both package over 1,000 well-known libraries.

Spack and HPC

Spack is the standard tool in high-performance computing whenever you need to build libraries like BLAS or MPI across many compiler and MPI combinations. It is widely used at US national labs and supercomputer sites.

go mod, Cargo, Mix, opam, Hex - Per-Language Standards

Go's go mod, Rust's Cargo, Elixir's Mix, OCaml's opam, and Erlang/Elixir's Hex are the de facto standards for each language. All of them ship lockfiles, workspaces, and build caches out of the box.

Maven, Gradle, sbt - JVM Package Management

Maven is still the most conservative choice in the Java ecosystem, Gradle is the default for Android and Kotlin, and sbt survives in Scala land. Even new Java projects increasingly pick the Gradle Kotlin DSL over Maven.

brew, Linuxbrew - Developer Machine Packages

On macOS, Homebrew (brew) is effectively the standard for non-admin dependency installation. On Linux, Linuxbrew competes with Nix, asdf, and mise. Most backend developers install language runtimes via brew and then pin per-project dependencies with uv, pnpm, or cargo.

Korean Adoption

Naver is experimenting with Zig for some infrastructure tooling, and Coupang has been growing its Kotlin footprint, gradually moving from Java + Spring Boot to Kotlin + Spring Boot. Toss chose Kotlin + Spring from day one, and Kakao mixes Go and Kotlin. Naver has reportedly contributed to swift.org/server while running Swift server experiments.

Japanese Adoption

Mercari runs some of its backend services on Swift on Linux and has contributed to swift-nio together with Apple. CyberAgent has experimented with Mojo for parts of its ML inference pipeline. LINE Yahoo has aggressively adopted Kotlin for its ad platform and messaging servers, and DeNA and SmartNews also rely heavily on Kotlin/JVM.

Speed Comparison - uv vs pip, pnpm vs npm, Bun vs esbuild

Benchmarks vary by machine and cache state, but the general trend is consistent. uv's cold install is 10-100x faster than pip, pnpm's monorepo install is 2-5x faster than npm, and Bun bundle is often faster than esbuild though plugin compatibility differs. The simplest measurement is to compare time uv pip install and time pip install from the same cache state.

Which Language and Manager to Pick

If you need every last cycle (OS kernels, game engines, HFT), C++26 and Rust are still the answer. For ML inference and GPU kernels, Mojo plus CUDA C++ are reasonable choices. For backend servers, Kotlin/Ktor, Go, Swift server, and .NET 9 minimal API are all viable. For small CLIs and daemons, Zig, Nim, and Crystal are attractive. For package managers, follow the per-language standard (Cargo, go mod, uv, pnpm), use Bazel or Buck2 in monorepos, and use Pixi or Nix for polyglot scientific computing.

Conclusion - The 2026 Landscape

2026 is not the year one language replaces all others; it is the year domain-optimal tooling became clear. C++26 and Rust hold systems cores, Zig picks up simpler systems code, Mojo accelerates ML, Swift and Kotlin lead servers, and .NET 9 occupies cloud backends. Package managers are taking cues from Cargo's combination of simplicity and rigor, with uv, Bun, and pnpm setting a fast and deterministic standard. Polyglot monorepos are coalescing around Bazel/Buck2/Pants plus Pixi/Nix for reproducible builds.

References

Discuss on Twitter • View on GitHub