From C64 to Rust Compiler – In Four Weeks.

I haven't written a single line of code myself. And yet, a working AOT compiler now exists, with its own stack machine, WGPU integration, and a complete website. This is the story behind it.

My last serious programming experience? A Commodore 64. BASIC, a bit of Assembler—the pride of getting a sprite to move. Then life happened, jobs, other things. Decades pass by quickly.

At the beginning of 2026, a question started bothering me: How far can you really go with modern AI if you have a clear idea but no current technical background? Not as an experiment, but to build something real.

The Idea

The core of KnotenCore is actually simple to describe: What if AI agents didn't provide their execution logic as uncontrolled code, but as a structured, machine-readable description? A JSON document describing an Abstract Syntax Tree. An engine that understands, compiles, and safely executes this tree.

No arbitrary code execution. No Python overhead. Instead: a deterministic, sandboxed execution channel—directly between what an AI thinks and what a system does.

"The idea wasn't to build an AI. The idea was to give it a safe way to touch the world."

The Process

I started on February 27th. Not with code, but with a conversation. I described what I wanted—and the AI started building it. Iteratively. One step at a time.

What surprised me most: The architectural decisions were still mine. Not because I had to penetrate them technically, but because I kept asking: Does this make sense? Why this way and not another? I understood the answers—and then I decided.

> cargo run --bin run_knc examples/core/showcase_v1.nod
Compiling KnotenCore v1.0.28-alpha...
✓ AOT compilation complete
✓ Stack machine initialized
✓ Execution successful

In four weeks, the following was created: a Rust-based AOT compiler, a stack machine with a real instruction pointer, a constant pool for memory deduplication, WGPU integration for GPU-accelerated rendering, an AsyncBridge for resilient network I/O, a sandbox security model—and this website.

What I Learned

The most important difference between a project that works and one that ends in nothing isn't technical skill. It's the ability to describe an idea clearly enough so another system can execute it. It sounds trivial. It's not.

I learned to ask questions I wouldn't have been able to ask before. I learned to evaluate answers without fully understanding them. And I learned that "I can't build this myself" is no longer a reason not to build something.

The tool is new. But the work—the idea, the direction, the judgment, the persistence—that remains with the human.

Where is it going?

KnotenCore is alpha. Experimental. Not production-ready—that's also stated at the top of the page, and I mean it. But it's real. The code runs. The architecture holds.

What interests me now: Who finds this exciting? Who has a use case they want to try out? Who sees in this approach—safe, compiled AI agent logic without Python overhead—something they've been looking for themselves?

I am not a developer. I am someone with an idea who found out that in 2026, that's enough to build something. Maybe that's the real message.