DEV Community

Cover image for The Story of Limn Engine — From a Toshiba with 4GB RAM to a 94/100 Game Engine
Kehinde Owolabi
Kehinde Owolabi

Posted on

The Story of Limn Engine — From a Toshiba with 4GB RAM to a 94/100 Game Engine

#web3 #webdev #tutorial #programming

The Story of Limn Engine — From a Toshiba with 4GB RAM to a 94/100 Game Engine

How a Nigerian teenager built a professional game engine with borrowed laptops, offline W3Schools, and pure determination.

Chapter 1: The Beginning

It started with a Toshiba laptop. 4GB of RAM. Offline W3Schools. And a teenager who loved coding.

I didn't have internet most of the time. I didn't have a mentor. I didn't have a team. I had a slow laptop, a borrowed copy of W3Schools, and a question that wouldn't leave me alone:

"Why do I have to write the same code in every single game?"

Chapter 2: The Frustration

I started with Pygame. I loved Python. But every game I made, I had to write the same things:

  • Edge detection (4 if statements every time)
  • Camera math (manual calculations every frame)
  • Collision detection (the same loops over and over)
  • Screen shake (complex transforms)
  • Particles (configure from scratch)

Every game. Every time.

I looked at other engines. They had the same problem. Nobody had move.bound(player). Nobody had camera.shake(5,5). Nobody had fixed() for UI.

"Why doesn't anyone build functions for the things we do in EVERY game?"

So I decided to build my own.

Chapter 3: The Laptop Heist Era

I didn't have a laptop of my own. Well, not at first.

Sister's Thinkpad (Behind Her Back)

My sister Damilola had a laptop before anyone else. I used it. Behind her back. She hated when I coded on it. But I needed to code.

That Thinkpad saw JGame (V1). Unpublished. Unfinished. But real.

Brother's HP (He Let Me)

My brother David got a laptop later. He LET me code on it. No guilt. No hiding. Just permission.

That HP saw TCJSGame V3. The breakthrough. The Tile Class. The flow state.

Sister's Toshiba (She Gave Me)

My sister eventually gave me her Toshiba. 4GB RAM. Slow. But mine.

That Toshiba saw V4. The dual-renderer. The 4 FPS → 60 FPS fix. The engine that would become Limn.

Three laptops. Two siblings. One engine.

Chapter 4: The Breakthrough

One night, I was staring at the screen. The engine was slow. 4 FPS. Unplayable.

I was using toDataURL() every frame. Converting the entire canvas to Base64. 60 times per second.

"Wait... why am I doing this every frame?"

I moved the cache creation inside if(display.once). Rendered once. Reused forever.

4 FPS → 60 FPS.

That's when I knew the engine was real.

Chapter 5: The Dual-Renderer

I realized that static content (tilemaps, backgrounds) doesn't need to redraw every frame.

So I created a hidden canvas called fake. Render once. Cache as an image. Paste every frame.

display.context.drawImage(fake.canvas, 0, 0);
Enter fullscreen mode Exit fullscreen mode

One operation. Thousands of tiles. 60 FPS.

The dual-renderer was born.

Chapter 6: The Features

Every feature in Limn exists because I was tired of writing the same code:

Feature What it replaces
move.bound(player) 4 if statements per object
fixed() Manual camera math every frame
destroy() Garbage collector hoping for the best
camera.shake(5,5) Complex transforms
move.particles.explosion() Configuring particles from scratch

"Common outcomes should be functions."

That's not just a tagline. That's the philosophy behind every line of code.

Chapter 7: The Name

TCJSGame was a working name. Technical. Hard to spell. No meaning.

I wanted something better. Something that described what the engine does.

Limn (verb) — to draw, paint, or portray.

Perfect. The engine helps you draw games into existence.

Chapter 8: The Community

Limn Engine has a growing community:

  • Discord server
  • Documentation website
  • Complete guides (Beginner → 10x)
  • Working examples (Space shooter, dungeon crawler, platformer)
  • Real games being built

Chapter 9: The Numbers

Category Score
Overall 94/100
Ease of Learning 96/100
Performance 95/100
API Design 96/100
AI Readiness 97/100

Better than Phaser in simplicity. Competitive with Godot in performance.

Chapter 10: The Philosophy

Limn Engine is not trying to be Unity. It's not trying to be Unreal.

"Limn Engine is trying to be the engine that respects your time."

No build tools. No package managers. No complex setup.

Just one file. Your creativity. And a philosophy that says:

"If you're writing it in every game, it should be a function."

Chapter 11: The Future

Limn Engine V1 is production-ready. But the journey is just beginning:

  • TypeScript definitions
  • Visual level editor
  • Mobile build wrapper
  • Larger community
  • More games shipped

The Toshiba is gone. The engine is here.

Chapter 12: The Credits

Limn Engine exists because of:

  • My brother David — who let me code on his HP
  • My sister Damilola — who had the first laptop, even if she hated me using it (and eventually gave me the Toshiba)
  • W3Schools offline — for being there when I had no internet
  • Pygame — for teaching me what was missing
  • The Toshiba — for surviving long enough to finish V4
  • Every user — for believing in the engine

The One-Line Summary

"Limn Engine is a 94/100 professional-grade 2D game engine built on a Toshiba with 4GB RAM, borrowed laptops, and a determination that never quit."

Try It Yourself

Draw your game into existence. 🚀

Top comments (0)