Why kern exists

Designed after the
requirements existed.

Why kern exists

Nobody has solved the full stack in 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.

Kern is the first language designed from scratch with all four -- because it started after all four existed and could learn from each of them.

# 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 -- nullable is opt-in
name: str   = "Marie"   # can never be null
alias: str? = none      # explicitly nullable

# Async like Node -- native event loop
task1 = spawn fetch_users()
task2 = spawn fetch_orders()
users  = await task1
orders = await task2

# Fast like Go -- compiles to a single native binary
kern build my-api.kern -o my-api
./my-api   # no runtime, no interpreter, no dependencies

All four. One language. No compromise.

GDPR compliance is currently a library bolted on

Every European company using Python, Go, or Node.js manages GDPR compliance manually. They bolt on libraries, write custom middleware, train developers, audit code. 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):
    analytics.track(user.email)  # personal data sent to analytics -- GDPR violation
    send(user.email, "Welcome!")

In Kern, this is a compile error:

fn send_email(user: User):
    analytics.track(user.email.value)
    # ERROR E0091: PersonalData<str> cannot be passed
    # without a valid ConsentRecord
    # Hint: use user.email.access(reason: "...", consent: record)

The only way to use personal data in Kern:

fn send_email(user: User):
    email = user.email.access(
        reason:  "send welcome email",
        consent: user.consent_record
    )
    analytics.track_event("signup")   # event only -- no PII
    send(email, "Welcome to Kern!")

No other language in the world enforces GDPR at the type system level. This alone justifies Kern's existence. The EU spends billions on compliance failures that Kern makes structurally impossible.

AI is now a backend requirement -- nobody treats it as one

Every modern backend needs LLM inference, embeddings, or RAG pipelines. In Python you glue together LangChain, an OpenAI SDK, Pinecone, and FastAPI -- four different APIs, four error models, four rate limit strategies, no type safety between them.

In Go or Rust you build everything yourself.

In Kern:

import std.ai.rag as rag
import std.ai.llm as llm
import std.ai.embed as embed
import std.ai.vector as vector

pipe = rag.pipeline(
    embedder: embed.local("nomic-embed-text"),
    store:    vector.qdrant("my-docs"),
    model:    llm.ollama("mistral")     # local, private, European
)
await pipe.index_directory("./docs/")?
answer = await pipe.query("How do I deploy to production?")?
print(answer.text)

A production RAG pipeline in eight lines. European providers by default. Privacy enforced. Every AI call audit-logged for EU AI Act compliance.

Kern's AI defaults are European by design:

And GDPR enforcement extends to AI. You cannot accidentally send personal data to an LLM:

email: PersonalData<str> = user.email

await llm.mistral().complete(prompt: email.value)
# ERROR E0091: PersonalData<str> passed to AI model without consent
# This is a compile error -- it never reaches production

Container management belongs in the language

Every backend developer writes shell scripts, Dockerfiles, and YAML to manage infrastructure. These are in completely different languages from the application code. Errors are only caught at runtime. Tooling is fragmented across a dozen different CLIs.

In Kern, infrastructure is a first-class language feature:

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")

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

Kern's container runtime is built to become fully native on Linux -- speaking directly to the kernel via namespaces, cgroups, and overlayfs. No Docker dependency. No Podman dependency. Just Kern and Linux.

European sovereignty is not a political argument -- it is a legal and economic one

This is the argument people dismiss as political. It is not.

The legal reality: Under the US CLOUD Act, data stored on American-owned infrastructure -- including GitHub, npm, AWS, Azure, and GCP -- can be accessed by US authorities without a European court order. This applies even if the servers are physically located in Europe.

The economic reality: European companies pay approximately €100 billion per year to American cloud and software vendors. Open source software contributes €65-95 billion to EU GDP annually -- and almost all of it flows through American-controlled infrastructure.

The practical reality: When a European startup's GitHub repository is flagged under a bad-faith DMCA claim, there is no recourse under European law. When npm goes down, every European Node.js deployment is affected. When Microsoft changes GitHub's terms of service, European open source projects comply or leave.

Kern's entire supply chain is European:

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

No other programming language can say this. Not even the ones created by European individuals. PHP was created by a Danish-Canadian and is governed by the Apache Foundation (USA). Erlang was created at Ericsson (Sweden) but is governed globally. Ruby was created in Japan. None have European governance as a founding principle.

How kern compares

What to say when
someone pushes back

Honest about what kern is
and what it's not