DEV Community: TheSpacetimeDebugger

Building a Quantum-Safe BB84 Simulation with Qiskit 1.0+ and NumPy

TheSpacetimeDebugger — Thu, 18 Jun 2026 10:06:08 +0000

Hi Dev Community 👋
I’d like to share a recent project: a production-oriented simulation of the BB84 Quantum Key Distribution (QKD) protocol, implemented using the modern Qiskit 1.0+ SDK and NumPy.
With the transition to Qiskit 1.0 and the deprecation of many legacy interfaces, I found that there are relatively few clean and up-to-date reference implementations for experimenting with quantum key distribution. This project was developed to provide a modern baseline for QKD research and educational purposes.
🛠️ Architectural Highlights
• Intercept-Resend Attack Simulation
Models an active eavesdropper (Eve) performing an intercept-resend attack, demonstrating measurement-induced state collapse and the security implications of the No-Cloning Theorem.
• Dynamic QBER Analysis
Continuously evaluates the Quantum Bit Error Rate (QBER). Whenever the error rate exceeds the theoretical security threshold of approximately 11%, the protocol automatically rejects the generated key material.
• Structured CLI Scenarios
Provides clear terminal-based simulations for both secure and compromised communication channels, enabling straightforward comparison of protocol behavior under different conditions.
🔗 Open-Source Repository
The repository includes the complete implementation, mathematical foundations, and usage instructions:
👉 https://github.com/TheSpacetimeDebugger/quantum-secure-bb84⁠�
I’d be interested to hear any feedback or suggestions regarding the implementation and overall architecture. 🚀

# I Built an AI-Powered Python-to-C++ Transpiler Entirely From My Phone. Here is How (and Why).

TheSpacetimeDebugger — Thu, 11 Jun 2026 10:40:31 +0000

Every developer knows the drill: you love Python for its speed of development, but when it comes to raw execution power, heavy data processing, or low-latency systems, C++ is king.

But what if you could write clean, expressive Python code and instantly transform it into highly optimized, production-ready C++? Even better, what if you could orchestrate this entire infrastructure from a device that fits in your pocket?

Meet Astmize ⚡ — an open-source, AI-powered Python-to-C++ transpiler with an active execution sandbox. And yes, I coded the entire ecosystem—both the frontend and backend architecture—directly from a 6.67" mobile phone screen.

Here is a deep engineering breakdown of how it works under the hood.

🛠️ The Architecture: Behind the Scenes of Astmize

Building a complex developer tool on a mobile device requires discarding heavy frameworks and relying on pure, asynchronous engineering. Here is how the orchestration layers interact:

1. Multi-Model AI Fallback Chain

Static AST (Abstract Syntax Tree) parsing can only get you so far with highly dynamic Python code. To ensure flawless code conversion, Astmize utilizes an AI Orchestrator via OpenRouter.

To counter server loads, API limits, or downtime, I built a sequential Fallback Chain:
(Qwen3 Coder -> DeepSeek -> Nemotron -> GPT-OSS ...)

If the primary model hits a rate limit or experiences high latency, the backend seamlessly routes the payload to the next model in the chain asynchronously, ensuring zero interruption for the user.

2. Live Cloud Execution Sandboxing

A transpiler is useless if you can’t verify the output. To solve this, I integrated the Wandbox API. Once the code is compiled into C++, the frontend triggers a remote compilation sequence running native GCC. The user receives real-time console feedback, compilation errors, and program outputs directly inside a dark, responsive cyber UI.

3. Lightweight Mobile-First Stack

Backend: A robust Python/Flask API hosted on a containerized infrastructure, fortified with strict rate-limiting (60 requests/minute) to handle high-traffic spikes securely.
Frontend: A single-file, zero-build vanilla JavaScript frontend designed to render beautifully across desktop and mobile browsers alike, complete with user-customizable editor configurations (font mapping, dynamic scaling, and custom tab sizing).

🚀 Live Demo & Source Code

The entire project is completely free, lightweight, and open-source. You can check it out right now:

🌐 Live Web Application: https://thespacetimedebugger.github.io/Astmize/
📦 GitHub Repository: https://github.com/TheSpacetimeDebugger/Astmize.git

📝 A Personal Note from the Developer (Behind the Glass)

If you’ve made it this far, thank you. I know most readers skip the closing thoughts, but I wanted to share something real with you.

I don't own a computer. Every single line of code in Astmize—from handling the asynchronous orchestration tokens down to wrestling with responsive CSS and debugging raw JSON strings—was typed with my thumbs using tools like Pydroid 3 on a small mobile device.

It was an exhausting, screen-switching nightmare at times, but watching hundreds of developers clone the repo over the last few days has made every thumb cramp worth it.

If this mobile-built project brings a smile to your face, inspires you, or adds any value to your workflow, please consider dropping a ⭐ Star on our GitHub Repository. It takes you exactly two seconds, but for a solo developer fighting limitations from a phone screen, it is the validation and fuel that keeps this project—and my future startup dreams—alive.

Thank you for riding along! ⚡

How I saved my Python-to-C++ Transpiler from failing by pivoting to Gemini AI (Built 100% on Mobile) 🚀

TheSpacetimeDebugger — Mon, 08 Jun 2026 12:56:25 +0000

Hey devs!
A while ago, I started building Astmize, a web tool to transpile Python code into optimized C++. In the first version, I tried building a strict AST parser. Long story short: handling type inference across languages entirely from a mobile IDE was an absolute nightmare, and I almost gave up on the project.
Instead of quitting, I decided to pivot. I completely rewrote the backend to leverage Gemini AI as the core translation engine. Now, instead of breaking on complex structures, the AI understands the logic and generates clean, optimized C++ code dynamically.
And yes, the entire stack (Frontend on GitHub Pages, Backend API on Render) was built, debugged, and deployed 100% using my phone.
Version 2.0 is officially LIVE! I'd love for you guys to break it, test it with some complex Python logic, and give me your brutal feedback.
🔗 Live Demo: [https://thespacetimedebugger.github.io/Astmize/]
📂 GitHub Repo: [https://github.com/TheSpacetimeDebugger/Astmize.git]
Let's hear your thoughts!

I built an open-source Python to C++ AST Transpiler entirely from my phone

TheSpacetimeDebugger — Mon, 25 May 2026 12:48:42 +0000

Hey everyone! 👋

I wanted to share a project I've been pouring my heart into: Astmize. It's an open-source Python-to-C++ transpiler built entirely from my mobile phone (using mobile editors since I don't own a PC at the moment).

Instead of using basic regex or string replacement, Astmize parses Python code into an Abstract Syntax Tree (AST) and maps the logical nodes directly into structurally equivalent, clean C++ code.

🛑 The C++ Design Bottleneck I Had to Solve

While developing the transpiler from my screen, I hit a massive roadblock regarding type emission. As we know, C++ is statically typed and strictly forbids using auto for non-static class data members without a direct initialization expression, because the compiler must determine the exact object memory layout at compile time.

In Python, fields are dynamically assigned inside __init__ via arguments (e.g., self.speed = speed). Initially, my compiler emitted auto speed; inside the generated C++ class struct, leading to immediate compilation failures.

💡 The Solution: Smart Type Inference Engine

To fix this from my phone, I implemented a custom Type Inference Engine in the Python backend that utilizes three core heuristics:

RHS Node Evaluation: Evaluates the Right-Hand Side assignment node to detect concrete primitive constants or explicit type initializers.
Variable Tokenization: Automatically splits attribute names by underscores and parses individual tokens against an explicit C++ type keyword library (e.g., detecting is_ or has_ prefixes infers a bool; tokenizing player_speed maps speed to int).
Safe Fallback Mechanism: If the type remains completely ambiguous, it safely defaults to int instead of emitting an illegal auto, ensuring structural layout validity and preventing compilation blocks.

The live dashboard integrates with standard GCC/Clang via the Wandbox API to compile and run the generated C++ code instantly on the fly.

🔗 Check it out here:

Live Web App: https://thespacetimedebugger.github.io/Astmize/
GitHub Repository: https://github.com/TheSpacetimeDebugger/Astmize.git

I'd absolutely love to get your feedback on the generated C++ structure, how you handle strict type emission in metaprogramming/transpilers, and if there are any C++ edge cases I should guard against!

Drop a ⭐ on GitHub if you find the concept interesting! Happy coding! 🚀