Now in active development

The XXML
Programming Language

A modern compiled language with explicit ownership semantics, powerful generics, and LLVM backend. Write safe, fast, and expressive code.

Clean, Expressive Syntax

Power and clarity in every line

example.xxml
#import Language::Core;
#import Language::Collections;

[ Class <Stack> <T Constrains None> Final Extends None
    [ Private <>
        Property <items> Types Collections::List<T>^;
    ]

    [ Public <>
        Constructor Parameters() ->
        {
            Set items = Collections::List@T::Constructor();
        }

        Method <push> Returns None Parameters (Parameter <value> Types T^) Do
        {
            Run items.add(value);
        }

        Method <pop> Returns T^ Parameters () Do
        {
            Return items.removeLast();
        }
    ]
]

[ Entrypoint
    {
        Instantiate Stack<String>^ As <stack> = Stack@String::Constructor();
        Run stack.push(String::Constructor("Hello"));
        Run stack.push(String::Constructor("XXML!"));

        Run Console::printLine(stack.pop());
        Exit(0);
    }
]

Why XXML?

Designed for developers who demand the performance of systems programming with the safety and expressiveness of modern languages.

Explicit Ownership

Control memory with clear ownership semantics using ^owned, &reference, and %copy modifiers. No garbage collector, no surprises.

Powerful Generics

Write reusable code with type-safe generics and constraints. Express complex type relationships with ease.

LLVM Backend

Compile to native code with LLVM. Get excellent performance and target multiple platforms from the same source.

Rich Standard Library

Core utilities, collections, I/O, networking, and more. Everything you need to build real applications.

Compile-Time Safety

Catch errors before runtime. The type system and ownership rules prevent common bugs at compile time.

Active Community

Join discussions, report issues, and contribute. XXML is built by developers, for developers.

Built for Real Applications

From high-performance services to safe plugin systems, XXML excels where explicit control matters.

Safe Plugin Systems

Build extensible native apps with runtime type discovery and API versioning. No GC overhead, with full ownership guarantees for extensions.

Serialization & Data

Auto-generate serializers for JSON, RPC, save-games, and configs using reflection and compile-time code generation.

Debugging Tools

Create object inspectors, debug UIs, structured logging, and test discovery systems powered by reflection.

Declarative DSLs

Express UI layouts, scene graphs, animation systems, asset manifests, and workflow graphs with structured syntax.

Native Services

Build backend services, daemons, and CLI tools where predictable memory and explicit ownership are essential.

Education

Learn ownership, lifetimes, and memory management through explicit, readable semantics. Perfect for teaching systems concepts.

Ready to dive in?

Start building with XXML today. The future of systems programming is here.

Get Started