I’ve been working on an experimental programming language called XXML. The project started from a frustration I kept running into across systems languages:

Languages with strong ownership tend to avoid runtime reflection.

Languages with rich reflection usually rely on GC or give up memory guarantees.

Compile-time code generation often requires a separate macro language.

I wanted to explore whether those tradeoffs are truly necessary.

What XXML is trying to do

XXML is a statically-typed, native language that:

Uses explicit ownership and borrowing (no garbage collector)

Supports runtime reflection while respecting ownership rules

Allows compile-time code generation using normal language constructs, not macros

Compiles to LLVM IR and produces native binaries

Reflection APIs are constrained so unsafe ownership operations are rejected at compile time. The goal isn’t “dynamic at all costs,” but introspection without losing safety.

What it’s useful for (so far)

Some concrete use cases I’m exploring:

Safe plugin/mod systems for native applications

Auto-generated serialization (e.g., JSON/RPC) without macros

Debugging and inspection tools that can reason about user types

Declarative domains (UI/layout/asset graphs) that benefit from structured syntax

What it’s not

This is early-stage and definitely not production-ready:

The ecosystem is minimal

The language is still evolving

Documentation and tooling are incomplete

I’m mostly interested in feedback from people who’ve worked on:

compilers

language runtimes

systems with heavy serialization or plugin boundaries

Code

GitHub repo: https://github.com/ThatSoulyGuy/XXMLCompiler or https://xxml-language.com

I’d especially appreciate criticism around:

the ownership model

reflection safety boundaries

where this design is fundamentally flawed

Thanks for reading — happy to answer questions.