How to automatically convert your Matlab Code to Python with AI

As someone who teaches programming for mechanical engineering students at Ravensburg Weingarten University, I've always been wondering about AI's ability to handle complex, real-world code conversion tasks. Sure, it's great for simple scripts and basic examples, but what about a full-fledged object-oriented system built over an entire semester? My initial skepticism was completely shattered when I tried Google's Gemini CLI on one of my challenging teaching projects.

What started as a potentially weeks-long manual conversion project turned into a 25-minute coffee break. Here's my story of how Gemini CLI completely blew me away.

The Challenge: Rewrite the full Matlab Codebase in Python

Let me set the scene. At our university, I teach a two-semester programming class for mechanical engineering students. The first semester introduces students to IT fundamentals using MATLAB - variables, loops, functions, the usual suspects.

In the second semester, we dive deep into object-oriented programming using MATLAB, and we do it through a comprehensive car simulation project. Students build a complex system with multiple interconnected classes (here only a selection is shown to get a better picture):

By the end of the semester, students have built a fully functional car simulator that can:

It's a substantial codebase for a 2nd semester student - typically 500-700 lines of object-oriented MATLAB code that represents weeks of student work.

The Problem: License Costs and Future-Proofing

Why are we even considering this task? Here's where reality hits. MATLAB licenses are expensive - really expensive. For a university, we're talking about thousands of euros per year for student licenses. And there's always the looming question: what happens if the university decides to cut ties with MathWorks? This is not far-fetched considering the tremendous efforts to cut costs.

Additionally, I wanted to adapt this excellent curriculum for another course that focuses more on general programming principles rather than engineering-specific tools. Python seemed like the natural choice - it's free, widely adopted in industry, and has excellent libraries for numerical computing and data analysis. To me, it is superior as an introductory language to programming for mechanical engineering students.

But here's the thing: manually converting the complete MATLAB code to Python? That's at least a weekend project that would require:

I was mentally preparing for 1-2 days of tedious work. Then I remembered Google's Gemini CLI that I'd been meaning to try out.

Enter Gemini CLI: I cannot believe this Tool is free

Google's Gemini CLI is a command-line interface that gives you access to Google's powerful Gemini AI models. Unlike web interfaces, the CLI allows you to work with local files, handle large codebases, and integrate AI capabilities directly into your development workflow.

I'll be honest - I did expect to get Python code back which would not do what it was supposed to do and I would have to debug my way through. Usually, they'd handle simple functions okay but completely butcher anything with complex object relationships or domain-specific logic. Sometimes I had the experience of reaching a point where I could have implemented it by myself faster as I was iterating and cursing at the cursor for not doing what I had in mind.

Getting started with Gemini CLI is straightforward. You need to follow the instructions on their [GitHub Repository](https://github.com/google-gemini/gemini-cli)

The setup process is well-documented, and getting API access is free for very generous usage levels (as of 07/2024) - perfect for academic use.

The Conversion Process: Surprisingly Simple

Here's where it gets interesting. Instead of trying to convert everything at once, I decided to take a methodical approach. I started with a simple prompt that included the entire MATLAB codebase. I provided the full semester's PDF as documentation, too. The code is quite well documented (over 70 pages), broken up into different tasks (where only the last task is concerning the codebase for this exercise)

Convert this MATLAB object-oriented car simulation to Python.
Preserve the class structure, maintain Excel integration, and ensure
all methods work identically to the original. Focus on clean,
Pythonic code while keeping the same functionality. In question, look for definitions in the provided documents. Feel free to ask if you need to clarify your tasks or certain implementation details. Use uv as a package manager, numpy and matplotlib for plotting.

What happened next blew my mind. As I said, I didn't expect too much, so I didn't pay attention. Within the next half hour, I went and sat outside, casually checking back if any requests had to be approved. When I came back after that half hour, Gemini had produced a complete Python implementation that included:

But here's the kicker - it wasn't just a mechanical translation. Gemini had made intelligent decisions about Python best practices. For example, it converted MATLAB's cell arrays to appropriate Python data structures, replaced MATLAB's `xlsread` with pandas' more robust Excel handling, and even added proper docstrings to all methods.

Okay, so I had Python code that looked good on paper. But the real test would be running it against our standard test scenario. I loaded up the same Excel configuration files we use in class and ran a NEDC cycle simulation.

The results were... identical. Not just close - identical. The Python version was producing exactly the same fuel consumption figures, acceleration curves, and efficiency metrics as the MATLAB original. Even the legends on the plots were the same. It even kept the German language for the plots as it was the case in the reference material.

Everything worked perfectly. I was prepared to spend hours debugging, but there was literally nothing to debug. The code just... worked.

Reflecting on why this worked so well, I think several factors contributed to the success:

The MATLAB code was well-organized with clear class hierarchies, proper encapsulation, and good documentation. This gave Gemini a solid foundation to work from.

I didn't just ask for a conversion - I provided context about what the code does, what the expected behavior should be, and what Python conventions to follow.

3. Gemini's Understanding of Both Languages

Gemini clearly has deep knowledge of both MATLAB and Python idioms. It didn't just translate syntax - it understood the semantic meaning and chose appropriate Python equivalents.

This wasn't a trivial toy example, but it also wasn't a million-line enterprise system. It was the sweet spot where AI really shines - complex enough to be challenging for humans, but structured enough for AI to understand.

One big factor was also the PDF which I attached to the prompt. I am sure this was used via RAG and as the code was documented in detail, it served for Gemini to understand what each class was doing and what formulas were used and why.

This experience has profound implications for how we approach curriculum development and tool selection in education:

We're no longer locked into expensive proprietary tools. If licensing becomes an issue, we can migrate our entire curriculum to open-source alternatives without starting from scratch. And the effort to do so is very reasonable.

The same conceptual framework can now be taught in multiple programming languages. Students can learn the principles in MATLAB and see the same concepts in Python, reinforcing the universality of programming concepts.

New teaching examples and exercises can be quickly adapted between languages, allowing for more diverse and flexible curriculum development.

This experience makes me optimistic about the future of programming education. AI tools like Gemini CLI don't replace the need for understanding programming concepts - they amplify our ability to teach those concepts effectively.

Students still need to understand object-oriented design, algorithmic thinking, and problem-solving. But now we can focus on these fundamentals without being constrained by the specifics of any particular language or tool.

We can teach the same car simulation project in MATLAB for engineering students who need to understand the mathematical foundations, and in Python for computer science students who need to understand general programming principles. The concepts remain the same; only the syntax changes.

Twenty-five minutes. That's all it took to convert a semester's worth of complex, object-oriented MATLAB code to perfectly functional Python. No debugging, no manual corrections, no late nights trying to figure out why the fuel consumption calculations were off by 0.1% or how to get that special plot style in matplotlib.

If you're an educator dealing with legacy code, considering a language migration, or just curious about what modern AI can do, I highly recommend giving Gemini CLI a try. You might be as surprised as I was by just how capable it has become.

Convert MATLAB to Python with Google Gemini CLI in Engineering Education

Recently, I set up my first virtual private server (VPS) for hosting my websites and applications. Chances are quite high, the webpage you are looking at right now is served by this server. After some research, I decided to go with Strato as my hosting provider. My friend Codie suggested them to me and they have great prices and all the options I would need. The setup process turned out to be quite straightforward, but I wanted to document the steps I took to make it easier for future reference and maybe help others who are embarking on a similar task.

This guide covers the complete setup from initial server provisioning to having a fully functional development environment with SSH access, user management, and basic web server configuration. Let's dive into the details!

Depending on your use case you want to carefully select the hardware for your VPS. If can either choose to set up a VPS which has more than enough power for your services and pay more or you could pay less but have the risk of running into hardware bottlenecks. 

Personally I went for a STRATO VPS Linux VC4-8, which has 4 cores, 8GB of RAM and 240 GB of storage. I pay 6 EUR/month for it and I think that's quite the steal. Hardware-wise it can handle small to medium tasks. It's definitely an overkill for just hosting a private website but you could run other services on it. Like I run my analytics tool called umami on there (blogpost: [here](https://manuel-ramsaier.com/blog/setting-up-your-own-google-analytics-umami)). I would refrain from e-mail hosting though. Tried it, it sucks.

Initial Server Setup and SSH Configuration

The first step in setting up any VPS is getting secure SSH access. I started by generating the necessary SSH keys using PuTTYgen to get the public key in the right format for the initial server installation. This was necessary as my ssh key was in the wrong format and the Strato Setup process did not recognize it at first.

Once I had initial access, the next crucial step was creating a new user account. Running as root is never a good practice, so I set up a dedicated user for my daily operations.

Creating a New User and Setting Up SSH Access

Here's the sequence of commands I used to create and configure the new user:

Security is paramount when setting up a server. One of the first things I did was change the default SSH port to reduce automated attack attempts.

On the client side, I edited the SSH config to have a more convenient connection setup. This makes it much easier to connect to the server without remembering IP addresses and ports every time.

This simple change can significantly reduce the noise from automated bots trying to brute force their way into your server.

UFW (Uncomplicated Firewall) is a nice way for managing iptables firewall rules on Linux systems, designed to simplify the process of configuring a secure network. So I block all by default and just allow the ports I want to allow. This would be the port 443 for ssl, port 80 for certbot and also my custom ssh port obviously (be **careful** not to lock you out of ssh). A custom way of ufw settings could look like this (custom ssh port: 2222):

With secure access established, it was time to set up a proper development environment. I went with my preferred tools and configurations:

This installs [git](https://git-scm.com/), [ohmyzsh](https://ohmyz.sh/) and [uv](https://github.com/astral-sh/uv) (my favorite package manager for python since poetry).

For Node.js development, I installed the latest stable version using the Node Version Manager (n):

I also installed the GitHub CLI for easier repository management and nginx for web serving capabilities:

Next, we will explore the services used for serving you website. I chose to go with [next.js](https://nextjs.org/) which is a react framework by vercel. This makes me sleep easy at night as I know that if the demand for my frontend grows too much, I can deploy easily to vercel and be done with it. For this website with almost only static content I think it is not a problem to worry about right now. 

So we will dive into Nginx, Certbot, systemd and a bit of shell scripting to launch your service in production or development mode.

Nginx, Certbot, and Next.js Configuration

Nginx (pronounced 'engine-x') is a powerful web server and reverse proxy that acts as the front door to your web applications. Think of it as a traffic controller that sits between your users and your actual application server. Here's what nginx does for your setup:

In my setup, nginx receives all incoming HTTP/HTTPS requests and forwards them to my Next.js application running on a custom port (I like to keep 3000 clean). This separation of concerns is a best practice - nginx handles web server duties while your application focuses on business logic.

Here's the nginx configuration I use for my website. I'll explain each section and provide a template you can adapt for your own domain:

Let me break down the key components of this configuration:

The `server_name` directive tells nginx which domain this configuration applies to. Replace `YOUR_DOMAIN.com` with your actual domain name.

The second server block at the bottom of the fileredirects all HTTP traffic to HTTPS for security. Only allow for HTTPS traffic to reach nginx.

The `location /` block handles all incoming requests and forwards them to your application:

The security headers protect against common web vulnerabilities:

I really love the ease of use of certbot. You just run it with the nginx flag enabled and you are good to go. Remember though, that you should check your renewal setup as the certificates once expired pretty much make your service unavailable. It cannot be reached anymore. 

Systemd is the service manager in modern Linux distributions that handles starting, stopping, and managing system services. For your web application, you'll want to create a systemd service that automatically starts your application on boot and restarts it if it crashes.

Here's the systemd service configuration I use for my Next.js application:

The systemd service calls a startup script that handles the application lifecycle. This script manages dependencies, builds the application, and starts it in the correct mode. Here's the `start.sh` script I use:

This script provides several important functions:

The script accepts a mode parameter (`dev` or `prod`) to determine how to run the application:

The script loads NVM to ensure the correct Node.js version is used, which is crucial for consistent application behavior.

In production mode, the script verifies that the build was successful by checking for the `.next` directory before starting the server.

Make sure your `start.sh` script is executable:

Setting up a VPS from scratch can seem a little bit much at first, but with the right approach and tools, it becomes quite manageable. 

Set up a new Virtual Private Server (VPS)

Hosting your own Google Analytics (Umami)

I recently saw  a post on X, where a user said how fascinated he was when switching from the not particularily user friendly UI of Google Analytics to an open source alternative called [Umami](https://umami.is/). My experiences with Google Analytics are limited but as I saw Umami being GDPR compliant by default (more info: [Umami FAQ](https://umami.is/docs/faq)), I wanted to give it a shot. 

Btw, Umami means **delicious savory taste** and originates from Japan where it was identified in 1908. Almost a century later, In 2002, it has been discoverd that the human tongue can distinctively taste umami besides the four typical tasts: sour, bitter, sweet and salty. Now let's get a taste of Umami Data Analytics.

Still new to all this, I checked the website first to get an impression. The data analytics platform offers: 

This sounds like exactly what I was hoping to get from a data analytics platform, so I went ahead and checked out the [GitHub Repository](https://github.com/umami-software/umami). Give it a star, if you decide to use it!

It's not such an obvious choice to me. Self hosting is great and all but the Umami Cload offers some generous Free Tier usage. 

So, to be fair, this for now seems absolutely enough for me and I would have gotten around some of the headache I describe further down below. But I also wanted to face this challenge and to try self hosting it. It is always good to know if you scale beyond the Free Tier if you have an easy route for self hosting vs. vendor lock-in. So, self-hosting it is!

Whenever I start to try out a new tool on my VPS (Virtual Private Server), I especially look for a uninstall.sh or a docker image. I burnt myself too often not to think about the way back before installing something on the machine which serves my homepages / SaaS. So I was pleased to see a docker image to use. 

Technically, it sounded straightforward. Change a few things in the docker-compose.yml file and spin it up. But as always, I got to do some preparations first:

Having set up all this I was happy to see the login screen on my custom domain. But this is where things turned South.

I was hit in the face with this error message, when trying to login with the default user:

This took a bit for me to resolve but I finally found the reason: The Cloudflare Proxy threw a Challenge via .html and Umami expected to get a JSON response. This was more obvious when I looked into the developer console.

I then changed the DNS entry for the umami subdomain to DNS only and voila, it worked. 

Now with the setup complete, I could finally add my webpage to my Umami Server. When you add a site to the dashboard, a unique ID will be assigned and you can get a code block to include on your webpage like so: 


The tracking code (*0cfe30f8-1b8e-47e1-8f3c-f5327c86fbd1*) allows umami to identify which webpage it was sent from. It is unique for every homepage. As most of my websites use next.js, you have to find a good place where to include this. One good option is the **_app.tsx** component. There wrap it into a Script (from next/Script) component and you are good. Make sure to deactivate extensions like *uBlock Origin* when you test it. Pay close attention to the *network tab* and you will see the request sent to your subdomain. 

The interface / dashboard looks clean, minimal and I like it very much. It works quite good and I am still at the beginning of getting to know all the functions / ways to analyze the data. So I will update this post when I have some more mileage in with this tool. So far I can fully recommend doing this. 

Convert MATLAB to Python with Google Gemini CLI in Engineering Education

Set up a new Virtual Private Server (VPS)

Setting up your own Google Analytics (Umami)