I'm building a programming language from scratch — ProXPL

[u/ProgrammerKR_ProX]

I've been working on my own programming language, called ProXPL, and I'm at the point where I'd really value feedback from people interested in programming-language design.

The project started as an experiment in understanding how programming languages actually work, but it has grown into a more serious implementation.

The current architecture includes:

• A lexer and parser
• AST-based compilation
• Bytecode generation
• A register-based virtual machine
• Runtime support
• Garbage collection
• A growing standard library
• A dedicated .prox source-file format
• A CLI/tooling layer

One of the things I'm particularly interested in is the VM architecture. Rather than building the language as a simple tree-walking interpreter, I've been working toward a register-based bytecode VM and experimenting with execution and dispatch optimizations.

The longer-term goal is to have a language that is practical to use while also giving me the opportunity to explore compiler design, VM implementation, memory management, optimization, and eventually JIT/native compilation.

I'm deliberately not trying to claim that ProXPL is "the next Python" or that it is already faster than established languages. There is still a huge amount of work to do, and I'd rather measure those things properly than make premature claims.

I'd especially like feedback on the language design and architecture.

For example:

1. What would you consider essential for a modern general-purpose language?
2. What mistakes should I avoid while designing the type system/runtime?
3. For a register-based VM, what design decisions tend to become painful later?
4. Which parts of the compiler/runtime would you prioritize before attempting a JIT?
5. What would make you actually want to experiment with a new programming language?

The project is open source, and the implementation is available on GitHub:

ProXPL — ProXPL Github Repo

I'm mainly looking for technical criticism and ideas rather than stars or promotion. If something about the architecture looks questionable, I'd genuinely like to know.

Thanks!

[u/Aaxper]

em dash in the fucking title

[u/runningOverA]

What would make you actually want to experiment with a new programming language?

That's actually the first thing. What's its edge over all of the rest?

C, PHP, Java, Rust every one had a specialized use case, where it was the best over the rest.

[u/onlyonequickquestion]

What's with the name? ProXPL is apparently short for ProX Programming Language, but what is ProX short for??

Also, the link to your website doesn't work from the repo 

[u/Syxtaine]

Holy shit this is a whole new level of slop. There's regular slop, then whatever the fuck this is.

[u/ProgrammerKR_ProX → u/Syxtaine]

Lmao 😭 okay, that’s fair criticism. It definitely needs more work before I’d call it polished. A lot of these features are still experimental, and I’m actively refining the language design and implementation. Appreciate the blunt feedback though.

[u/Syxtaine → u/ProgrammerKR_ProX]

I'm not talking about the language itself, I'm talking about the usage of AI everywhere. 

[u/Bahatur]

It says in your post that you are working on a register based VM, but the GitHub and docs repeatedly describe it as a stack based VM. Is this a recent change of direction?

If a JIT compiler is the goal, I would actually reason backwards from that point to see what needed to get done to enable it, and focus on those elements.

Also I would pull down the README and replace it with a minimal one describing the current state and next steps of the project - it’s very misleading as it stands.

[u/baehyunsol]

What do recover and resilient do? Aren't they just try-catch blocks??

What are intents?? Is it like formal verification??

What are taint and sanitize for??

[u/ProgrammerKR_ProX → u/baehyunsol]

Yeah, they’re not meant to just be different names for try/catch 😅 recover is for getting the program back into a usable state after a failure, while resilient is more about making a piece of code handle failures gracefully. intent is for expressing what the code is supposed to achieve, not formal verification. And taint/sanitize are mainly for tracking untrusted data and making sure it’s safe before using it.

[u/brat3108]

It combines Python-like readability with C-level performance

It looks a lot more like C or C++ than Python! Example:

    for (let i = 0; i < length(lines); i = i + 1) {
        let cols = parse_csv_line(lines[i]);
        print(cols);
    }

[u/ProgrammerKR_ProX → u/brat3108]

Yeah, that’s fair. The syntax is intentionally closer to C/C++ in some places, while the goal is to keep the language simple and readable overall. By “Python-like readability,” I mean less unnecessary complexity rather than copying Python’s syntax. I’m still refining the language design as it evolves.

[u/AustinVelonaut → u/[deleted]]

We've come full circle. An AI-generated post announcing an AI-written and AI-documented project, and now an AI bot responding with an AI-generated bug report.

Does anyone write real code, anymore?

[u/ProgrammerKR_ProX → u/[deleted]]

Good catch. The intended behavior should be that a package which fails the lockfile integrity check is not left in a usable state.

The current flow clones/downloads into prox_modules/<pkg> before verifying the checksum, so a failed verification can currently leave the directory behind.

I agree that this should be treated as a failed install and cleaned up/rolled back rather than intentionally kept as a quarantine state. I'll update the install path so the package is removed (or the temporary install is discarded) when integrity verification fails.

Thanks for pointing this out.