Omar Mahdi

Founder @theoverlordcorp
Building a game engine, but for web dev:

[Omar Mahdi @bloeys]

Months struggling to explain @theoverlordcorp, but finally have something I believe to be clear to a good degree.

Check it out (and signup for the beta!): https://t.co/fGooSVwdt7

Wish I had this when I was fundraising 😂

[Omar Mahdi @bloeys]

I am not sure if I ever shared this, but this is our first-ever (and embarrassing) changelog sent to our closed-beta testers.

Compare v0.0.3 with v0.0.7, where we are starting to move beyond stability and to adding cool stuff!

I think we'll have a public changelog somewhere.

[Omar Mahdi @bloeys]

One of our beta users said:

"You don't think in lines of code you think of structure. Of units of work."

I love it!
It connects to the heart of what we are building and how we are thinking @theoverlordcorp

We are expanding the beta soon: https://t.co/fGooSVwLiF

[Omar Mahdi @bloeys]

@GloriousPtr If you want instant file search across the entire OS this is the best

https://t.co/fY3TZeeSQg

[Omar Mahdi @bloeys]

@htmx_org Please just use a VM and stop with lambda (for most cases) 🥲

[Omar Mahdi @bloeys]

@SebAaltonen Do you have some "base" layer that you reuse across all these game engine experiments?

Because these all seem much higher quality than somebody throwing AI at building a game engine.

[Omar Mahdi @bloeys]

It's *not* the same price. Cache is ~66% more expensive compared to Grok 4.5.

$0.3 -> $0.5

[SpaceXAI @SpaceXAI]

Introducing Grok 4.6.

It delivers frontier intelligence and is a significant improvement over Grok 4.5 at the same price.

[Omar Mahdi @bloeys]

I'll comment mainly on what it means to program, AI as compilers, and reading AI code to keep a shared understanding.

Software is an encoding of large-scale logical structures built to direct a machine to accomplish a task.

We encode *how* something is done, but not what the thing *is*. The "what" isn't encoded. Only an outside observer who knows the "what" can judge outputs as "correct".

Programming is therefore two distinct things, both of which are necessary:

- The building and continuous update of logical structures
- The encoding of these logical structures into software

From punch cards to high level languages, all programming involved these two aspects. You built logical structures in your mind that would accomplish a task, and you encoded those structures in software.

You read AI code because that's the main way to absorb the existing logical structures and how they are encoded. Without that, you are staring at a soup of files, no different than a programmer joining a new project.

AI coding doesn't feel like programming because you barely build logical structures of your program, and the AI never learns, so *no one* has a mental model.

It also doesn't make sense to compare AIs to compilers because natural language prompts don't sufficiently encode the desired logical structures, and we currently have no way to represent those. Compilers get ~formally specified inputs.

I discuss this more in a recent blog: https://t.co/td1iUzzzz1

[Omar Mahdi @bloeys]

I'll comment mainly on what it means to program, AI as compilers, and reading AI code to keep a shared understanding.

Software is an encoding of large-scale logical structures built to direct a machine to accomplish a task.

We encode *how* something is done, but not what the thing *is*. The "what" isn't encoded. Only an outside observer who knows the "what" can judge outputs as "correct".

Programming is therefore two distinct things, both of which are necessary:

- The building and continuous update of logical structures
- The encoding of these logical structures into software

From punch cards to high level languages, all programming involved these two aspects. You built logical structures in your mind that would accomplish a task, and you encoded those structures in software.

You read AI code because that's the main way to absorb the existing logical structures and how they are encoded. Without that, you are staring at a soup of files, no different than a programmer joining a new project.

AI coding doesn't feel like programming because you barely build logical structures of your program, and the AI never learns, so *no one* has a mental model.

It also doesn't make sense to compare AIs to compilers because natural language prompts don't sufficiently encode the desired logical structures, and we currently have no way to represent those. Compilers get ~formally specified inputs.

I discuss this more in a recent blog: https://t.co/td1iUzzzz1

[Omar Mahdi @bloeys]

Overcode is split into 3 main components:

1. Buffer

A data structure optimized for text reads and edits. A linked list of fixed-size byte arrays such that most operations don't allocate.

Each bucket has metadata about what's stored on it, like how many Unicode chars it has, how many bytes, and so on.

Not thread safe. Simple, fast, and operates in UTF8.

2. Session

Sessions are thread safe objects that represent a single 'document', like a file or an in-memory string.

Each session owns a buffer and controls access to it, and handles things like LSP, tree-sitter queries, and other "shared" state about the document.

3. View

The view is the visible and interactive code editor you see. A view renders a single session, and there can be many views to one session.

Each view owns state like cursor position and scroll, and has it's own independent window size. Runs are produced by and saved on each view.

Views also owns all user IO and turns inputs into commands the session can understand, like turning a 'cut' operation into `read_range`+`copy`+`delete_range`.

This means that you can have many editors all showing the same file, but looking at different sections. Since they all read/write the same session, edits by any view are immediately visible to all others.

AI agents work with sessions, which means you and the AI see each other's changes.

There are a few more components, but they are more about orchestrating all this.

[Omar Mahdi @bloeys]

We are finally moving our embedded IDE, Overcode, to be a run-based rendering and layout system, and I am just happy that it naturally lends itself to being zero-copy!

Runs reference text segments of the underlying data structure. IDE writes update the doc 'version', which forces runs to rebuild.

Runs also make things like selection/find highlights and other IDE decorations simpler to implement. They also make the rendering loop relatively simple.

The old version used to do the ultra-naive thing of doing layout, syntax highlighting, and so on every frame an IDE is visible even when nothing changed, but time for an upgrade.

Although, the stupid way was still so fast we hit stable 240fps on all machines tested haha. Computers are fast!

[Omar Mahdi @bloeys]

Do that with software too!

I have a chat group where I just record features or things I do in @theoverlordcorp.

It both feels good (milestone hit) and can be used later to do cool montages like this or just to see how far you have come. Can be motivating to see ancient clips.

[Mari @MadMaraca]

Friendly reminder to take progress screenshots with your art 😌

[Omar Mahdi @bloeys]

@valigo Me finally making @theoverlordcorp public 😂

Only that games are released ~finished, while we have come a long way *and* have a long way to go.

[Omar Mahdi @bloeys]

@valigo They missed a few steps before the constitution:

1. Create a company
2. Make the company successful and become filthy rich
3. Buy an island
4. Purchase a flag from Amazon and put it on the island
5. Declare the island a country and apply for the UN
6. Write a constitution

[Omar Mahdi @bloeys]

Thanks Tom

[Omar Mahdi @bloeys]

@pikuma I was told some British guy was looking to know that as well

[Omar Mahdi @bloeys]

Very interesting, looking forward to seeing it.

This mirrors our approach in @theoverlordcorp, which if pushed enough is not only good for agents, but unlocks new dev workflows for humans and human/AI collab.

Oont seems to have logical statements and all that? For us the approach currently is more practical/operational.

We encode an ontology for a specific domain (web dev), along with validations and rules, and expose tooling to both humans and AI custom built to operate on the ontology.

The outcomes are similar to what you describe: SOTA models unnecessary, massive context improvements and faster time to task finish. Since we also have a whole GUI/engine/IDE, the benefits extend to the human as well.

Very excited about where all such approaches will take software dev!

[Omar Mahdi @bloeys]

Since the early days of @theoverlordcorp I realized that an IDE that works through a semantic/ontological structure, rather than a soup of files, would allow semantic diffs.

Semantic diffs would be like:
- Endpoint X logic updated
- Column Y added to table Z

The code diff is there, but viewed through the ontology of the IDE, which increases the value of reviews and makes reviewing much more enjoyable.

After >1.5 years, this idea has become a reality!

It was an eye-watering amount of work to reach a point where this feature is both possible and a priority, but it finally exists.

It's a basic version and far from my vision, but nevertheless a step in the right direction, and should ship to our closed beta users within a day or two 🚀