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.