Running Local LLMs in Game Engines - Here's My Journey with Godot + Ollama

Yakub — Sat, 27 Dec 2025 14:22:03 +0000

I randomly got an idea yesterday. AI is everywhere right? Well let's make it even worse. I realized I've never actually looked into integrating LLMs into games. Particularly game engines like Unreal, Unity, or Godot.

I've always loved playing around with game engines in the past, though I never really made a full game. So I was like, "let's just do it".

The Spark: FunctionGemma

While researching, I came across Google releasing FunctionGemma - a model specifically designed for function calling from natural language. Basically, it takes text input and can identify when to call specific functions and with what parameters.

This immediately clicked for me. Theoretically, I could build something like a helper bot in my game that actually understands player commands: "Go mine some iron", "Pick up all the dropped items nearby", "Build a solar panel over there"... The LLM would parse the intent and trigger the appropriate game functions.

And the best part? It's small enough that I can run it completely locally on my RTX 3070. No API calls needed.

Time to Learn Local LLMs

I've never run an LLM locally before. Didn't have a idea how to do it - always just used OpenAI APIs. So I was like, now is the time!

Researching how to connect a game to an AI led me to an important realization: running the LLM directly inside the game engine isn't ideal, especially for early testing and development. You want a separate server handling the inference.

I decided to give Ollama a try for the LLM server. For the game engine, I went with Godot since I could quickly play with it. Downloaded it, set up FunctionGemma model with a simple ollama pull functiongemma, and had a local LLM server running in minutes.

Connecting Godot to Ollama

Now came the fun part: making Godot talk to the LLM.

Godot has built-in HTTPRequestnodes that make this surprisingly straightforward, I just needed to learn very simple Godot Script and how to make the request to the server and handle the stuff.

The basic flow looks like this

Create an HTTPRequestnode in your scene
Send a POST request to http://127.0.0.1:11434/api/chat with your message
Parse the JSON response to get the AI's reply

Here's the simplified concept:

const OLLAMA_URL = "http://127.0.0.1:11434/api/chat"
const MODEL = "functiongemma"
func send_request() -> void:
    var body = {
        "model": MODEL,
        "messages": conversation_messages,
        "tools": tools,  # Your game function definitions
        "stream": false
    }

    var json_body = JSON.stringify(body)
    var headers = ["Content-Type: application/json"]
    http_request.request(OLLAMA_URL, headers, HTTPClient.METHOD_POST, json_body)

For function calling, you define your available "tools" (game functions) with their parameters. The LLM then decides which functions to call based on the user's request:

{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get the current weather for a location",
        "parameters": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "description": "The city and country"
                }
            },
            "required": ["location"]
        }
    }
}

When the LLM responds with tool_calls, you execute those functions locally and send the results back. It's a conversation:

user → LLM → function call → result → LLM → final response

Here's the important part: the LLM doesn't actually execute anything. It just returns structured data saying "hey, I think you should call mine_resourcewith these parameters." Your game code makes the final decision. So this not some AI slop game that breaks or does super weird stuff.

What I Learned

I loved this whole process. It made me understand LLMs and all the stuff around running them on a much deeper level — how inference servers work, function/tool calling behind the scenes, the round-trip conversation flow and much more cool stuff!

What's Next

I definitely plan to play with this a lot more. There are some genuinely interesting use cases where LLMs in games could be actually useful - not in the bad way we sometimes see today, where "AI-first" is just shoved everywhere and shines in our faces where we don't want or need it.

Some ideas I want to explore:

Intelligent NPC companions that understand context and can perform complex tasks
Natural language command interfaces for strategy or simulation games
Dynamic dialogue systems that don't feel like scripted trees

Oh, and if you want to try this yourself 👉 I've put together a working demo you can clone and run right now. It's a minimal Godot project with everything set up: the HTTP client, function definitions, and the full round-trip conversation flow.

Feel free to use it as a starting point and build on top of it!

If you're also thinking about experimenting with this, let's connect! The barrier to entry is surprisingly low, and you'll learn a ton in the process. I study economy and come from web dev!

Have you tried integrating LLMs into game engines? I'd love to hear about your experiences in the comments!

My Thesis Accidentally Made Me a Data Scientist

Yakub — Fri, 26 Dec 2025 18:38:25 +0000

Prologue

So after months of procrastination, I finally started my master thesis. You know how it is. Anyway, I'm finishing my economics degree and I needed a topic.

I went with something that actually kind of interested me: scanning and analyzing job postings in the IT industry. The plan was to compare the EU vs US vs India – what skills are employers looking for, what's different across regions, that kind of stuff.

So I started scraping Glassdoor for data. Easy enough right? Then came the fun part – actually analyzing this stuff.

See, I figured I'd use Stata or some other analysis software they taught us at school. That's what you do with data, right? Load it into Stata, run some regressions, call it a day.

Except... I don't really have numbers. I have text. Job descriptions. Thousands of them.

And Stata doesn't really vibe with text.

So I'd need to use something like Python anyway to process all this text before I could even think about analysis. And at that point I was like – aight, let's just do it ALL in Python then. lol.

Never coded in Python before, by the way. It couldn't go that bad right?

Well guess what. It actually started to be fun.

And it turns out the methodology is going to be way more advanced and complicated than I expected. We're talking NLP, LLM pipelines, structured data extraction – the whole thing. This isn't just "import data, run analysis" anymore. This is actual engineering (I think, don't judge me I come from React). And the problems I'm solving, I feel like they're actually helping me think more clearly. The decisions I make on the way are shaping the thesis and I like that.

I'm on day 3 now.

My codebase is roughly 5,800 lines of Python.

Just the Python files. We're not counting configs or existential crisis logs.

I came here to write an economics thesis. I think I might be leaving as... something else entirely. Python Data Analyst or how they even call it.

And honestly? I'm kind of here for it.

In the following posts,
I'll dive into the interesting stuff I'm solving while building this project. Drop a follow if you want to join along!