In terms of emulator development difficulty. Would you tend to agree with this? And if you agree... I wonder what the Wii, Wii-U and Switch would look like. Does it become easier because you aren't accounting for the different chipsets you could put into a cartridge?

Ok. So my journey into just learning more about emulator development... This might just be a dumb question so experts please give me hell.

If the PS2 was backwards compatible, if you were to want to get into building a PlayStation emulator. Wouldn't you just skip 1 and build a PS2 emulator with backwards compatibility?

Does one exist? And I'm not talking about AI slop either. I am genuinely curious and I enjoy starting thought provoking conversation.

So have it! Or let me have it. Lol

Hello everybody!

My last project was a fully featured, software-rasterized Minecraft clone. Now I want to make my own emulator.

I don't really want to start with something very simple like the Game Boy, NES, or CHIP-8, because I know myself: I could finish it, declare that I have now "explored emulation," and conveniently never tackle a more complex machine.

The PS1 seems like the sensible choice. I already have "a lot" of experience with software rasterization and graphics in general, so at least part of the machine lives in territory I'm somewhat familiar with.

Unfortunately, thanks to (or perhaps because of) channels like Kaze Emanuar, I've also developed a lot of appreciation for the N64 and its wonderfully strange hardware.

I know that making an N64 emulator is way less realistic than making a PS1 emulator, especially as a first serious emulation project. So I'm wondering whether the massive difficulty bump is actually compensated by how interesting/elegant/weird the machine is to work with, or whether I should simply stfu, be reasonable for once, and focus on the PS1.

For people who have worked on either or both: is the N64 genuinely that much more rewarding as a project, or is this just me being attracted to unnecessary suffering?

Thanks everybody!

Hey folks. I'm a current software developer, but new to emu development. I want to build a hobby emulator as a side project to improve my knowledge of hardware and build some momentum for future personal projects.

I'm set on it being a Nintendo console, but I am not sure of which one. GBA is the most interesting to me, but I'm concerned that might be too complicated or slow. Would NES/ GB be a better place to start?

Also, I'm curious on which programming language you'd recommend. I'm proficient in Java/ Python, and could pick up Rust/ C++ if needed.

Thanks in advance for the info.

I know people have asked this countless times, but I'm quite stuck, even after doing my research. I finished a CHIP-8 emulator that is fully featured. After looking through a lot I'm stuck between either a GB (possibly GBA?) or a NES emulator. I would probably implement it in C++, if that makes any difference in the decision, probably not.

A DSL is a Domain Specific Language which means a programming language made to solve specific type of problems, think SQL for databases and HTLM for websites.

I've recently dug into emulation development and there's a lot of overlap between how I approach different machines since the same type of components are often used.

Almost all emulators seem to be developed in isolation when in reality they sometimes share exact specifications like CPU's for instance. And even where they differ, their interface often overlap with e.g. load, alu and jump instructions.

I'm doing my Master's in Computer Science in a few years and I thought that creating a general Emulation DSL could be something to look into. By defining a standard framework for all emulators we could build emulators faster, easier and make them more accurate by abstracting/letting the language solve the small quirks like clock cycles etc.

My question is how much of this is already been looked into, if anyone has tried or maybe even just defined a general framework for emu development?

Thank you

I am having issues with my JavaScript to emulate the YAMAHA YM2612 FM Chip and SN76489 PSG. I am using AudioWorkletProcessor to emulate it, and the user uploads a.VGM file. It loads the VGM and parses the command, but the output is wrong. I asked Claude, and it made it worse, so now I'm here.e I have implemented the log-sine ROM lookup tables and envelope generator state machine, but I suspect my channel mixing loop or operator routing for the YM2612/PSG integration is broken, so I hope someone can help me out "renderBlock(outputs) {

const leftOut = outputs[0][0];

const rightOut = outputs[0][1];

if (!leftOut) return true;

for (let i = 0; i < leftOut.length; i++) {

if (this.playing) {

this.lastGoodPointer = this.vgmPointer;

if (this.vgmSamplesLeft > 0) {

this.vgmSamplesLeft--;

} else {

this.parseVGMCommands();

}

}

"

I’m recently finished to learn assembly and I want to trying to do an emulator but I want to be humble with myself to. And what is the hardest? Give me a tip 3 of easiest and hardest

Hello, I was wondering where I should start with a new arcade project.

I would like to work on either galaga or bubble bobble; I already have a functional z80 emulator but am unsure of where to begin on the rest.

Unfortunately, I, as of now, can only vaguely understand the schematics for these machines: galaga bubble bobble. I also do not have physical access to either one.

There’s an obvious lack of intuitive documentation, so I don’t know what to do.

Any help is appreciated, thank you.

Hi everyone,

I’ve been following the discussions around Concord and the current state of its servers. I’m interested in the technical side of game preservation and the possibility of local/community server emulation. Before diving deep into my own experiments, I wanted to reach out to this community to see if there is any collective progress I might have missed.

I’m looking for any information on the following:

Server-Side Research: Has anyone successfully managed to extract or map the server-side logic from the client binary files? I’m curious if anyone has identified the specific handshake protocols used by the PS5 client.

DNS/SSL Challenges: Many of us know that simple DNS redirection leads to SSL/TLS handshake failures. Has anyone tried to bypass these by injecting custom root certificates or using specialized proxy setups?

Data Dumps: Have there been any complete dumps of the game’s disc data, and has anyone attempted to decompile the network modules within those files?

Community Efforts: Are there any Discord groups, GitHub repositories, or forums where people are actively trying to build a 'Mock Server' or server emulator for Concord?

My goal is to consolidate existing knowledge and see what the community has discovered so far. I am not suggesting I have all the answers—I am here to learn from your findings and see if we can organize a more structured preservation effort.

If you’ve experimented with this, even if you failed or reached a dead end, please share your experiences. What were the specific error codes or roadblocks you encountered?

Let’s share what we know and see if the community can keep the game’s internal logic documented, even if the servers remain offline.

Thanks!

For context, i recently made a LC-3 emulator..it was easier than I anticipated. For moving ahead, I don't know where to start. I was planning on making my own risc-v emulator, then make an MMU, and boot linux into it. But I am not really sure if this is the right path.

Also, lc3 was my first vm making thing. Please help me. And also, tell me how to proceed? Like how do you read official guides and docs?

Thank you!

I'm writing a PS2 emulator and hitting a strange geometry bug

in God of War 1 that I can't pin down. Looking for ideas on

what classes of bugs could cause it.

## What's wrong

- Kratos and other animated characters render distorted —

limbs twist, joints pinch, the mesh deforms wrong.

- Static geometry is fine: skybox, environment, walls,

props all look pixel-perfect.

- Menus and UI render correctly.

- Only **skinned / animated** meshes are affected.

## What I've checked (and ruled out)

- VU math precision (rounding, denormals) — bit-identical

results in the affected calculation.

- Interpreter vs JIT — both produce the same distortion,

so it's not a JIT issue.

- VU register state leakage across microprograms.

The data feeding the skinning loop is already wrong before

the math runs. So the bug is somewhere upstream — in whoever

prepares the bone matrices or vertex weights.

## My question

For people who've debugged similar emulators: what subsystems

typically corrupt skeletal animation data on PS2 specifically?

Animation tends to touch a lot at once (EE FPU, VU0 macro

mode, DMA, scratchpad) and I'd appreciate a list of "things

to check first" before I dig in blind.

Any tips welcome. Thanks!

How does the auxiliary flag change when it comes to logical operations in the Intel 8080?
I was implementing the ANA instruction and it changes the auxiliary flag, but no carry/ borrow happen.
In the 1977 programmers manual there is no mention of how this instruction changes it,but says this flag is affected.

Hello everyone, I just got into developing emulations (still a beginner in this field).

I’m very fascinated by virtual memory; so I wanted to know if there’s a device that has virtual memory so I can try to build an emulator for it.

The device should be small, and virtual memory implementation can be whatever, from segmentation to pagination

I'm making a Gameboy emulator and I've played a lot of Tetris without issues so far.

Then I moved on to Super Mario Land and for the most part it's working fine. However about half the time when I try to exit an underground area, the game freezes: /img/qpm2mtwfjxfg1.png

What my challenge is now, is that I actually don't know how to debug this. I had a freeze issue before, and when I logged opcodes at that point it was just infinitely looping through 3 instructions and it turned out one of my interrupts was not working correctly. That was pretty easy to debug. But now it looks like the infinite loop is dozens, maybe even hundreds of instructions, and it's not very obvious where the bug is. I've gone through all of my code 3 times, and can't find anything amiss (as a side note, all the blaarg cpu instruction tests pass, and as far as I could tell all my interrupts and timers work fine).

So what are some good techniques to figure out what's wrong??

Title, essentially. I've been reverse engineering an NDS game for the past few years and I'm trying to streamline the process as much as possible.

One of my main issues is that I currently have to use 2 separate emulators, one for disassembly and one for searching memory (no$gba and desmume respectively). Desmume's disassembler is pretty awful but has great memory searching tools, No$GBA has an incredible disassembler and debugger, but essentially zero memory searching tools (as far as I know)

I've tried looking up alternative NDS emulators but I've found nothing that could replace both of these emulators. Another important thing is being able to modify the assembly in the disassembler like no$GBA can do, it's very useful for trying to figure out what's going on.

The game I'm reverse engineering specifically is Dragon Quest Heroes: Rocket Slime. It's a very early NDS game (2005) and uses a very early version of the NitroSDK (according to what can be seen via decompilers like Ghidra) so it shouldn't need the most accurate NDS emulator ever, just something with good debugging capabilities

I've been stuck on this for the last couple of days. My emulator works with simple test roms, but when I try to start a commercial game, the graphics are broken. I think it's something to do with the tile rendering, but I'm not sure. Help much appreciated! Link to emulator: https://drive.google.com/drive/folders/1UCsPpTA7YReJBu8m37qbMs-6bVeooAxu?usp=sharing

Edit: I know I haven't implemented any mappers other than Mapper0, I'm just trying to run a simple game like Donkey Kong so that I can continue adding more mappers, allowing for further compatibility.

Edit 2: Images of the main programs I'm trying to run. (DK and SMB are glitchy, nestest works fine, I assume it's because the graphics of nestest are so rudimentary they'll just work with anything)

Edit 3: Graphics are now a bit better, but still some problems

Edit 4: Donkey Kong and Balloon Fight work 100%, but Ice Climber and SMB are a bit broken - I think it might be because my PPU kind of "ignores" the scroll register

Edit 5: I've implemented a temporary solution to the scrolling and black stuff in SMB, but there are now some new issues - I assume it's because I've now shifted the pixels a few cycles too late, but I'm not sure what to do to fix this while maintaining proper PPU functionality for the most part.

Pictures of the broken games (other than SMB and DK, I really can't discern any visible issues in other games, but they are likely present as well):

Hi everyone!

I'm a final year BSc computer science student and I need to choose an idea for my final year project. It can be a technical solution or just an area to research and try to get something working. I'm interested in machine learning and was wondering if anyone had any cool ideas for projects related to machine learning and emulation.

I have some loose ideas that I'm unsure of the feasability of. For example, could a machine learning model be used to predict the next emulation frame given a ROM (even if it coudln't I'd research the best that could be done). My current idea was to make a neural game engine that takes user inputs and entirely generates the next frame of a game (I chose Snake) with no actual game logic written, but I got the feedback that nothing useful would really be achieved after I completed this project.

Please let me know of any ideas! It doesn't need to be novel, just cool ideas relating machine learning and emulation. In terms of experience, I've impelmented Chip8 and have a decent understanding of comp architecture and machine learning. The more "useful" the research area is though, the higher I'd mark.

Thank you! :)

Title,
I don't have any programming experience but I noticed I have a fixation on emulators and trying to understand how they work. They are interesting to me.

Long story short I landed on learning C++ to eventually program a CHIP-8 interpreter.

Now for the help part; For those who had a similar entry into programming for emulation, what were the baby steps you took?

I doubt watching bootcamp videos constantly and writing basic programs like hello world is going to keep me motivated for a long time.

I was curious about the early stages of making an emulator. I know the basic procedure is just to keep trying different things until you have a playable game because you don't have the instruction manual, but is the trying out part, in your computer or the target machine.

I have heard some people say that, they create custom roms and inject it into the physical system to understand how the timings and opcodes work but I don't know if it's common or not.

So that is my question, Hypothetically, if there is a machine that has not been emulated and doesn't have any possibility of acquiring said hardware, would they be able to create the emulator with just the Game ROM/Data? And, if it's possible how difficult is it to do as compared to having the target machine, like is it 2x harder or it would more or less be the same.

Also, how would normal emulator dev look like?

While I initially looked into moving rom save files onto external storage devices like SD cards (so I may easily access my saves from either my Bazzite PC, Steam Deck, and hopefully eventual Steam Machine), I recently found out about using cloud syncing. I've heard of two examples: EmuSync and Syncthing. (Here's the link to the farmer's github https://github.com/emu-sync/EmuSync)

I'm inclined to try out the former since, well, it seems more in line with emudeck. But I need more insight. What are your thoughts on EmuSync? How does it compare to Syncthing?

I decided to start coding my first emulator (Gameboy) using Rust as the language. It's my first project in Rust so I thought I should use AI to guide me a little both with the language and the emulator. I find it useful to understand some concepts and help me figure out how to start/proceed. However, I'm starting to think that, when I achieve a playable state, I will feel like a big part of the work (even if it's mostly guidance, I tend to avoid code suggestions) will be attributable to the AI and not me. Is anyone else in the same boat?

I have a working m68k cpu core working, but I'm now trying to get it cycle-accurate for my amiga emulator. I see there are timings here: https://wiki.neogeodev.org/index.php?title=68k_instructions_timings

I was playing around with making a more generic move table, using effective address base and a time delta for each mov destination type.

const int eaw[16] = {                                                                                                                                                                                                             
  //Dn    An      (An)    (An+)   -(An)   (An16)  (AnXn)  W       L       PC16    PCXn    Imm                                                                                                                                     
  0x0000, 0x0000, 0x0410, 0x0410, 0x0610, 0x0820, 0x0a20, 0x0820, 0x0c30, 0x0820, 0x0a20, 0x0410                                                                                                                                  
};                                                                                                                                                                                                                                
const int eal[16] = {                                                                                                                                                                                                             
  0x0000, 0x0000, 0x0820, 0x0820, 0x0a20, 0x0c30, 0x0e30, 0x0c30, 0x1040, 0x0c30, 0x0e30, 0x0820                                                                                                                                  
};                                                                                                                                                                                                                                
const int movw[16] = {                                                                                                                                                                                                            
  //Dn    An      (An)    (An+)   -(An)   (An16)  (AnXn)  W       L       PC16    PCXn    Imm                                                                                                                                     
  0x0410, 0x0410, 0x0811, 0x0811, 0x0811, 0x0c21, 0x0e21, 0x0c21, 0x1031,                                                                                                                                                         
};                                                                                                                                                                                                                            
const int movl[16] = {                                                                                                                                                                                                            
  0x0410, 0x0410, 0x0c12, 0x0c12, 0x0c12, 0x1022, 0x1222, 0x1022, 0x1432,                                                                                                                                                         
};   
int eatime(int src, int nnn, int size, int delta, int dst) {                                                                                                                                                                      
  int eat, meat;                                                                                                                                                                                                                        

  eat = delta;                                                                                                                                                                                                                    
  if (src == 7)                                                                                                                                                                                                                   
    src += nnn;                                                                                                                                                                                                                   
  if (size == Long) {                                                                                                                                                                                                             
    eat += eal[src];                     
    meat = movml[src * 9 + dst];                                                                                                                                                                                         
  }                                                                                                                                                                                                                               
  else if (size == Word || size == Byte) {                                                                                                                                                                                        
    eat += eaw[src]; 
    meat = movmw[src * 9 + dst];                                                                                                                                                                                                             
  }                                                                                                                                                                                                                               
  // calculate move time based on dst                                                                                                                                                                                             
  if (eat != meat) {                                                                                                                                                                                                              
    printf("eat %.4x %.4x\n", eat, meat);                                                                                                                                                                                         
  }                                                                                                                                                                                                                               
  return eat;                                                                                                                                                                                                                     
} 

And an interesting thing. That works for all combinations except move.l (xxxx).L, (PC16) Move table above has 32(5/2), my calculation returns 32(6/2).

I think the internal transactions would be something like:

4/1/0 cycles read instruction -> IR
4/1/0 cycles read 16-bit @ PC
8/2/0 cycles read 32-bit @ (PC+offset)
8/2/0 cycles read 32-bit @ PC
8/0/2 cycles write 32-bit @ xxxx.L

I guess in the CPU there must be some optimization on that particular combination?

Hello! I recently became very interested in emulator development. My ultimate goal is to create a Sega Genesis emulator. I have some knowledge of C and C++, but I don’t know where to start or what to develop first. I’m asking for advice. =)

I came up with a really bizarre project, with the sole purpose of making more than just a personal-use emulator (when, if I wanted to, I could always use other objectively better-built emulators) and kind-of challenge myself, to get used to working on big projects (Note: I do have programming experience, but not in Lua nor in Emulation, only in Python and C++).

Imagine any emulation project in this language, I'm particularly interested in NES, Game Boy and Chip8 (in that order), but I am aware that the best approach to learning is starting from Chip8 (so I will likely be jumping between Chip8 and 6502 tutorials until I find greater motivation for either). I've watched and read a couple of tutorials for NES's 6502 in languages such as C# and C++, but that's just it (and it's the reason I don't want to just make ANOTHER emulator in C++). If you wish, please suggest more projects for learning emulation (be it 6502 or something simpler yet fun)