DEV Community: teejayRedex

P++: A Language That Speaks Both Interpreter and Compiler

teejayRedex — Sat, 24 May 2025 03:15:21 +0000

What if your language could prototype like Python, but run like C?

That’s the goal behind P++, a new experimental programming language I’ve been building from the ground up. With P++, developers don’t have to choose between ease of use and performance. You get both:

🌟 Key Features:

🧠 Interpreter Mode for fast iteration and debugging
⚙️ LLVM Compiler Mode for JIT/AOT execution and performance
🧪 A new REPL shell where you can write and run P++ line by line
📦 Simple syntax, extensible architecture (custom IR, LLVM backend)

Why P++?

Languages like Python make it easy to build ideas quickly, but struggle with speed. Languages like C++ give you power—but come with more complexity and compile times. P++ is designed to bridge that gap.

Switch between interpreted and compiled modes on the fly. Write something, test it, then turbocharge it when you're ready.

What It Looks Like:

num as int32 = 42
ptr as *int32 = &num

def square(val as int32) -> int32:
    return val * val

class Box<DataType>:
    value as DataType

    def __init__(v as DataType):
        self.value = v

    def get() -> DataType:
        return self.value

# Using inline assembly
def add_asm(a as int32, b as int32) -> int32:
    asm {
        "mov eax, a"
        "add eax, b"
        "ret"
    }

arr as *int32 = malloc(int32, 5)
*arr = 99
free(arr)

In interpreter mode, it's instant. In compiler mode, it’s JIT-ed and executed using LLVM.

I’m Inviting You

This is still in early development. I’m putting it out there to get feedback, suggestions, and collaborators. Whether you're into language design, compiler theory, or just curious about new tech, I’d love your take.

👉 Check out the repo. Share your thoughts. Let’s build something together.

Would you use a language like P++? What features would you want?

How to Expose C++ Qt WebView and Window Functions to Python?

teejayRedex — Thu, 21 Nov 2024 15:23:23 +0000

I'm working on a project where I need to integrate a Qt6 WebView into Python. The WebView should allow dynamic control from Python, including:

Setting the window size and style (e.g., resizing, full-screen,
borderless).
Loading HTML content or a URL dynamically.
Interacting with JavaScript in the WebView.

What I Want to Achieve:

Dynamically set window properties (e.g., resize(800, 600), borderless mode, etc.).
Load either:

Raw HTML content (loadHtml).
A remote URL (loadUrl).
Execute and interact with JavaScript in the WebView (e.g., calling JS
functions or retrieving results).
Expose all these functionalities to Python without relying on PySide
or PyQt due to licensing concerns.

What I’ve Tried:

I’ve attempted to use pybind11 to expose a custom C++ class that wraps QApplication and QWebEngineView. Here's an example of my pybind11 bindings:

#include <pybind11/pybind11.h>
#include <pybind11/stl.h>
#include <QApplication>
#include <QWebEngineView>
#include <QString>

namespace py = pybind11;

class WebView {
public:
    WebView() {
        int argc = 0;
        char *argv[] = {nullptr};
        app = std::make_unique<QApplication>(argc, argv);
        view = std::make_unique<QWebEngineView>();
    }

    void resize(int width, int height) {
        view->resize(width, height);
    }

    void setHtml(const std::string &html) {
        view->setHtml(QString::fromStdString(html));
    }

    void setUrl(const std::string &url) {
        view->setUrl(QUrl(QString::fromStdString(url)));
    }

    void exec() {
        view->show();
        app->exec();
    }

private:
    std::unique_ptr<QApplication> app;
    std::unique_ptr<QWebEngineView> view;
};

PYBIND11_MODULE(qt_webview, m) {
    py::class_<WebView>(m, "WebView")
        .def(py::init<>())
        .def("resize", &WebView::resize)
        .def("setHtml", &WebView::setHtml)
        .def("setUrl", &WebView::setUrl)
        .def("exec", &WebView::exec);
}

The code compiles fine, and I cannot load basic HTML and URLs in the WebView from Python due to ImportError: /home/red-x/Documents/GUIEngine/MyQtWebViewApp/qt_webview.cpython-312-x86_64-linux-gnu.so: undefined symbol: qt_version_ta. However:

I cannot tweak window styles (e.g., borderless or full-screen).
Ubuntu
I can't execute or retrieve JavaScript results from Python.
I feel my approach isn't complete or robust for all the features I
need.

Constraints:

No PySide or PyQt: I need a solution without these libraries because
of their licensing restrictions.
Why pybind11?: It fits my requirements for lightweight and
license-compliant bindings.

Questions:

How can I expose Qt's window and WebView functionalities (e.g.,
styles, JavaScript interaction) to Python using pybind11?
Is there a better way to handle this integration without relying on
PySide or PyQt?
Are there examples or open-source projects that achieve something
similar?

Environment:

OS:  Windows 10 or Ubuntu 20.04
Qt Version: 6.4.2
Python Version: 3.12
Compiler: g++ with C++17

Any help or suggestions would be greatly appreciated!

Do Python developers still create GUI desktop apps? If so, what tools do you use?

teejayRedex — Thu, 10 Oct 2024 16:31:54 +0000

Hey fellow Python devs!

I’ve been wondering how often people in the community still build desktop GUI applications these days, especially with Python. With web apps and mobile development being so prominent, is there still demand for desktop apps in your work or side projects?

If you do build desktop apps, what frameworks are you using? Would you be interested in a framework that feels like Flutter but for Python? One that handles all the low-level stuff for you and allows you to focus on building user-friendly interfaces with a similar approach to Flutter's widget system?

Just curious to hear your thoughts! Would love to know what’s working for you or what challenges you face when building GUIs with Python.

Looking forward to your insights! 😄

Yoo Devs, Where’s Your Old Laptop?

teejayRedex — Mon, 30 Sep 2024 00:24:10 +0000

Hey devs! I’m currently teaching a group of passionate students who are eager to learn programming, but most don’t have access to laptops or desktops. If you have an old one lying around that you’re not using, consider donating it! Your unused tech could open up a whole new world for them. 🙌💻