Why kern exists

Every major backend language was designed before GDPR, before large language models, before container-native infrastructure, and before European digital sovereignty became a legal and economic priority.

They all require you to bolt these things on — as libraries, middleware, and external tools — in different languages, with different error models.

kern is the first backend language designed after all of these became requirements.

All four.
One language.

Go gives you performance. Python gives you readability. Node gives you async. TypeScript gives you types. Every team picks two or three and accepts the tradeoffs of the rest.

Readable like Python

fn process(users: List<User>) -> Result<Report>:
    active = users.filter(fn(u) -> u.active)
    return Ok(Report(count: active.length))

Type safe like TypeScript

name: str   = "Marie"   # can never be null
alias: str? = none      # explicitly nullable

Async like Node

task1 = spawn fetch_users()
task2 = spawn fetch_orders()
users  = await task1
orders = await task2

Fast like Go

kern build my-api.kern -o my-api
./my-api   # no runtime, no interpreter, no dependencies

Every European company using Python, Go, or Node.js manages GDPR compliance manually. It fails constantly because nothing in the language itself prevents a developer from passing personal data to the wrong place.

In Python, this compiles, runs, and silently violates GDPR

def send_email(user):
    # personal data sent to analytics -- GDPR violation
    analytics.track(user.email)
    send(user.email, "Welcome!")

In kern, this is a compile error

fn send_email(user: User):
    analytics.track(user.email.value)
    # ERROR E0302: PersonalData<str> cannot reach a sink
    # that does not declare PersonalData
    # Hint: declare the parameter PersonalData, or redact first

The only way to use personal data in kern:

kern

from std.compliance import check_consent

fn send_email(user: User, consent: str):
    check_consent("process", consent)
    analytics.track_event("signup")   # event only, no PII
    send(user.email_plain, "Welcome to kern!")

AI is now a backend requirement.

LLM calls with compile-time safety. Model output is Untrusted<str> at the source, so prompt injection is a type error. European providers by default.

main.kern

from std.cap_ai import ai_root, ai_complete
from std.untrusted import untrusted_validate_length

fn main():
    ai = ai_root()          # only main mints it
    reply = ai_complete(ai, "mistral", "How do I deploy?")
    # reply is Untrusted<str>: validate before use
    answer = untrusted_validate_length(reply, 1, 4000)
    print(answer)

deploy.kern

import sys.container
import sys.compose

async fn deploy():
    app = compose.stack("production", [
        compose.Service(
            name:  "db",
            image: "postgres:16-alpine",
            env:   {"POSTGRES_DB": "myapp"},
            volumes: ["db-data:/var/lib/postgresql/data"]
        ),
        compose.Service(
            name:    "api",
            image:   "myapp:1.0",
            ports:   ["8080:8080"],
            depends: ["db"]
        )
    ])
    await app.up()?
    log.info("Production stack running")

Container management belongs in the language.

The same language, the same error handling, the same type system — for your application code and your infrastructure code.

Sovereignty has a stack.

Sovereign European silicon is real work, but it is a decade away. The language layer sits above the hardware and the OS. It is where data is shaped, encrypted and moved. Own the language and you own the security and privacy that reach the user, today, without waiting for anyone’s chip foundry.

Applications
Your software, sovereign by construction
Language · kernWhere Europe starts
Security, encryption, privacy enforced by the compiler
Operating system
Bound to the hardware it runs on
Silicon & hardware
A decade of work. Necessary, but not where we wait

Every component is EU-hosted, EU-governed and EUPL-licensed. No CLOUD Act. No FISA 702.

Source codeCodebergGermany

Package registrypkg.kern-lang.euFrance

CI/CDWoodpeckerGermany

Static hostingCodeberg PagesGermany

Default cloud LLMMistralFrance

Default vector DBQdrantGermany

Default local LLMOllamaOpen source

No GitHub. No npm. No AWS.
No Cloudflare.

Honest about what kern is and what it's not.

kern is for

European companies subject to GDPR who are tired of compliance being a manual, error-prone process
Public sector organisations mandated to reduce US cloud dependency
Developers who love Python's readability but need Go's performance
Teams building AI-powered backends who want European providers and privacy by default
Anyone who believes critical digital infrastructure should not be governed by a single American corporation

kern is not for

Data scientists who need NumPy and pandas — use Python
Systems programmers building operating systems — use Rust
Teams with ten years of Go investment — switching has a cost, stay with Go
Projects that need Windows support — kern targets Linux (production) and macOS (development)

Built in Europe.
Built to last.

Get started How kern compares

curl -fsSL https://kern-lang.eu/install.sh | sh