dmonterocrespo

I ported the decompiled C code of the 1998 PlayStation version of Metal Gear Solid to the ESP32-S3.

The game code compiles directly to Xtensa machine code, with the PlayStation SDK, GPU, GTE, CD drive, scheduler, and controller replaced by software layers.

It runs on a Seeed Studio XIAO ESP32-S3 Sense with 8 MB PSRAM and microSD.

The post goes into the porting process, memory layout, scheduler, software rendering, debugging, and the bugs that took the most time to find

It's a fork of https://github.com/devos50/qemu-ios. The idea is to reverse engineer the Samsung S5L8702 SoC to emulate the real system.

We can all combine our own knowledge, enthusiasm, and AI to do amazing things. It's like using better computers with better processors. For programming, I could perfectly well use a PC from 2001.

I admire the entire community behind reverse engineering iPods. I'm active in various community channels, sharing information with them. I wouldn't be an engineer without using the tools and knowledge of those who came before me. The translator (I speak Spanish) changed the text a bit, and some words came out in all caps, but I've already corrected the names.Thanks to everyone for taking this to the next level!

Here are some details about how I made the iPod Classic 6G emulator and what I encountered along the way: https://x.com/DMonteroCrespo1/status/2095882094455009695

I think the community is very close to achieving it

Hi, I wrote that note by hand; I didn't use Claude. The hypotheses were based on the fact that other emulations used different paths to reach the playback device. For example, I analyzed Rockbox to see how they managed to play music on this chip. I did use Claude and Gemini to investigate and create the emulator code

Some improvements are still needed, but the idea is to run the original Apple firmware without modifications. I'd like to be able to run it on a Raspberry Pi Zero someday... a very thin layer will lift the iPod Classic 6G emulator

Even though I used AI, it took me months to decipher parts of the emulation. I had to study, and I loved learning things I didn't know. It's also a very beautiful learning path; everything related to technology is magical. Engineers from all over the world are trying to revive the iPod and products that are no longer commercially available.

I used AI, and I mention it in the post. I'm also an engineer at IBM, and I know a bit about operating systems and embedded systems, which helps me understand and decipher parts of the iPod. I also have a small workshop where I was able to repair an iPod that had been broken for a few years. The community is truly amazing, and it supported me in subsequent research such as freemyipod and https://github.com/devos50/qemu-ios

I didn't know that, it's a good fact. When I had my iPod 6G, that album art animation looked amazing.I haven't been able to unlock it because it has many upgrade directions that I haven't been able to decipher

I saw your work and I thought it was excellent; that's another step I want to take: being able to run the games and the cover flow! We're one step away from making the iPod free forever.

One of the things that gave me a lot of trouble was unlocking the music player. Reverse engineering it was really difficult. I investigated many possible variations, tried searching on https://freemyipod.org for memory register information, but there was nothing for this particular iPod that could help me with the music player. Now I'm trying to unlock Cover Flow, which is something I really liked the first time I saw it on my iPod.

I've been developing a QEMU emulator for the iPod Classic 6G (Samsung S5L8702) that boots the original, unmodified Apple retailOS. Navigation, the disc, the screen, and the music library worked for a while, but the music player appeared partially rendered and without sound. There were four different errors, and the last one was my fault in a way that I found amusing enough to write about.

For months I've been trying to emulate the iPod Classic 6G I have in my drawer, without success. After a long time, I finally managed to get it running, although it's still somewhat rough. In QEMU, I managed to boot the original, unmodified Apple retailOS. Navigation, the disc, the screen, and the music library worked for a while, but the music player appeared partially rendered and without sound.

One thing we already know is that the firmware is from Apple and is encrypted, so there's no legal download. I have an iPod Classic 6G from 2008. With the help of Claude Code, I was able to create code to extract it using emCORE. I extracted the contents of the flash memory and decrypted the image myself.

and the boot ROM cannot be read from the running device. I confirmed the latter the hard way, and along the way, my iPod restarted several times (pressing the center and menu buttons for 5 seconds to restart it).

There is no datasheet for the SoC. Each model register that allows unlocking some part of the guest is derived from a write operation performed by the guest itself,

Code and notes, including the ~16 hypotheses I had to retract along the way

The page is not working

I recently saw a video about this, and it happened a few years ago. But today we don't rely so much on GPS to locate an address. Thousands of devices around the world connected by antennas can calculate proximity better than a GPS

We are currently in discussions to see if we can emulate that device in the velxio.dev electronics emulator

Great job!

It's a bit crazy that they used characters as markers to detect the use of Asian countries. I think in the near future they might change the intelligence of the model based on where you live

I tried the Arduino + RC low-pass filter example (using PWM as a DAC) and it was pretty impressive to see the output voltage actually smooth out instead of just flipping between 0 and 5V

What I found interesting is that the ADC reading follows the filtered signal, so you can actually observe the analog behavior from the firmware side.

Feels like this could be really useful for teaching, especially to show how digital signals turn into analog in real circuits without needing a full lab setup

Velxio 2.0 is live.

A free, open-source emulator for 19 embedded boards: Arduino, ESP32, Raspberry Pi, RISC-V , running real compiled code in your browser.

The best part: it's fully local.

No cloud dependency. No student accounts. No data leaving your network. Self-hostable with a single Docker container.

Universities and bootcamps can deploy it on their own servers and give every student access to a complete embedded development environment, for free.

I've been working on this for over a year, and just shipped v2.0 with ESP32 emulation (via QEMU), a custom RISC-V core, and Raspberry Pi 3 support that runs real Python

Creator here! Just saw this was posted. I've been working on the 2.0 release to move beyond simple AVR emulation. Integrating QEMU for the ESP32 and Pi 3 (Linux) was a massive challenge, especially maintaining sync between the different emulators in a single browser tab.

Hi HN,

I recently spent some time going through MiniMind, and it’s a remarkably clean resource for understanding the modern LLM stack under the hood. It’s a minimal, end-to-end implementation of a ~25M parameter GPT-style model in pure PyTorch, designed to be trained from scratch on a single GPU

Instead of heavy abstractions, it uses straightforward PyTorch while still implementing modern architectural choices like RMSNorm, SwiGLU, RoPE, and even MoE variants. What makes it valuable is that it doesn't stop at the forward pass; the repo covers the entire training lifecycle. You can trace the data flow from tokenizer training and pretraining, right through to Supervised Fine-Tuning (SFT), LoRA, preference optimization (DPO/PPO), and distillation

It’s small enough to actually read the source code end-to-end, but realistic enough to serve as a baseline for architectural experiments rather than just a toy example.

Curious if anyone here has used this (or similar minimal codebases) to test custom architecture modifications or train highly specialized small-scale models

I'm currently testing the pipeline locally on a PC with an RTX 4060, and it's a great fit for this kind of hardware

Thanks, I didn’t know about Renode.I’ll definitely take a look.

The reason I’m specifically exploring JavaScript is because of a project I’m working on (velxio.dev), where everything runs in the browser, so having a JS/WASM-based approach would make integration much simpler

Right now I’m experimenting with a QEMU based setup and exposing it through WebSockets, but the performance isn’t great and the emulation tends to be unstable (I’ve been hitting crashes under certain workloads).

That’s partly why I’m looking into alternative approaches , either pushing more into the browser, or finding a more robust backend model.

Appreciate the suggestion!

One thing that’s been particularly frustrating is trying to find complete documentation for Xtensa. I’ve looked around quite a bit, and it feels like there isn’t a fully open, detailed spec available. Most of what exists is either partial, behind NDA, or spread across different sources.

I’ve been looking into this space recently while exploring ESP32 emulation.

I came across this repo: https://github.com/lcgamboa/qemu/ which is quite interesting, but it’s not really a JavaScript/browser-based simulation. It relies on QEMU and actual hardware emulation rather than running in a JS/WebAssembly environment.

From what I can tell, it handles the Xtensa architecture at a much lower level, which makes sense for accuracy, but also makes it harder to bring into the browser.

It made me wonder whether a higher-level approach (similar to how AVR emulators work in JS) could be viable for ESP32, or if the complexity of peripherals (WiFi, BLE, etc.) makes that impractical.

Curious if anyone has explored alternative approaches here.

Has anyone explored this or knows of existing approaches/tools?

I've donated about $100 USD to it. KidCAD is great software because many engineering systems are too expensive for students. Another very interesting project that's gaining traction is the Arduino emulator https://velxio.dev

The Qwen 3.5 models are currently the best open-source models, but they are far behind proprietary models in speed and accuracy. I'd say they're about 60% on par with OpenAI and Anthropic models.

Similar to this project https://github.com/davidmonterocrespo24/DaveLovable ?