I built a Game Boy emulator in F#

139

eelvis70 about 5 hours ago 36 commentsRead Article on nickkossolapov.github.io

FR version is available. Content is displayed in original English for accuracy.

⚡ Community Insights

Discussion Sentiment

90% Positive

Analyzed from 701 words in the discussion.

Discussion (36 Comments)Read Original on HackerNews

debugnik•about 4 hours ago

Cool to see F# here! Emulators are a great way to learn a language. On first sight you chose well between more or less idiomatic F# for each job.

Some low hanging fruit to reduce allocations: the discriminated unions in Instructions.fs could be [<Struct>], reusing field names to reuse internal fields.

Also, minor nitpick but I'm confused about some of the registers. They are already of type byte, the setters with `a &&& 0xFFuy` don't add anything over `member val A = 0uy with get, set`. I'm guessing this changed over time.

cermicelli•about 5 hours ago

Finally someone putting in actual human effort to learn something, and not a LLM helped me build X in Y minutes.

There is some hope for humanity after all I suppose.

hectdev•about 3 hours ago

It's always going to exist. People still build things with hand tools in the year 2026. Let's call it Artisanal Coding.

z500•about 4 hours ago

That's so cool! I love F#, but I wrote a little Smalltalk interpreter in it and I can confirm it isn't exactly a speed demon for that kind of thing if you use it as intended lol

tombert•about 4 hours ago

I've found that with F#, I get better performance if I do dumb imperative stuff, but keep the side effects within a function. At that point, the functions can basically be "pure" but you can get decent speed.

For example, I usually like using the `Map` data structure, and that's a pretty neat immutable structure and is usually fine for most stuff, but when performance becomes critical, it's easy enough to break into a boring imperative loop with a regular hash map. If I keep everything contained into one function, I usually can avoid feeling super dirty about it.

ragnese•about 3 hours ago

Yes! That's exactly how you should do it while working with a language that doesn't have a compiler that will aggressively analyze, and rewrite and optimize your code for you. (So, most languages with "heavy runtimes" that support a bunch of dynamic stuff and JITs)

There are basically two points to programming with immutable-first data. One, eliminate certain classes of data race concurrency bugs. Two, less mutable state in a given context makes it easier to reason about.

So, if you're inside a function scope and you aren't launching any concurrent operations from inside that function, you don't have to worry about benefit #1. If you're inside a function (and you're not reaching out for global mutable state), then the context you need to keep in your working memory is likely fairly small, so a few local mutable variables doesn't significantly harm "understandability" of the implementation (in most cases). So, you really don't have to worry about #2, either. Make your functions black boxes with solid "APIs" (type signatures), and let the inside do whatever it needs to make it work the best.

Just because premature optimization is the root of all evil, it doesn't mean we need to jump right to premature pessimization...

jackmott42•about 4 hours ago

With some care about what features to use and when, F# can be very fast. Which is nice, use functional paradigm when you want, or low level imperative code in hot loops if you need. But yeah if you use linked lists and sequences and immutable data types everywhere it sure isn't Rust.

yoyohello13•about 4 hours ago

I always find emulators written in functional languages impressive. It tends to be much easier to map hardware to an imperative language. I enjoy seeing the functional abstractions people come up with.

skrebbel•about 4 hours ago

Did you look at the code? F# has mutable variables/arrays and this uses that for eg memory.

yoyohello13•about 3 hours ago

Yeah I did see that part. Although he mentioned his Chip8 emulator which was fully immutable. Still interesting so see when people use the mutability escape hatches.

CSMastermind•about 4 hours ago

Insanely cool. I've had it in the back of my mind to write a Rust compiler for the game boy for a long time and everytime I see something like this I think about brushing off that project.

hmokiguess•about 5 hours ago

F# is super fun, awesome work!

thrownawaysz•about 3 hours ago

mildy related but wasn't there an emulator (maybe not GB but NES or SNES?) which had a visual panel showing each CPU cycle step by step? afaik it was very slow but the 1000% accuracy was the goal not playability.

mkw5053•about 3 hours ago

Very cool. Makes me want to build something with F*

cachius•12 minutes ago

How about a Game Boy Game?

MattCruikshank•about 4 hours ago

Sorry for the tangent - does anyone have some really zoomed in views of GB, GBColor, GBA screens in operation? I'd love for retro shaders to be able to more faithfully reproduce.

I mean, ideally, we'd run different color test patterns through, in different lighting conditions, to build a really detailed model, right?

Galanwe•about 4 hours ago

I guess buying the second hand devices wouldnt be that expensive.

dmitrygr•about 3 hours ago

> No code is free from the influence of AI these days, even learning projects

Speak for yourself

__loam•about 4 hours ago

I'm actually starting a new project to create a gba emulator in zig, and also starting with chip8. I'm going to skip nand to tetris because I played Turing complete. Cool to see I'm on the right track!

WoodenChair•25 minutes ago

Yes, CHIP-8 is kind of the standard "I want to get into emulators" first project. In my latest book Computer Science from Scratch we go CHIP-8 -> NES in chapters 5 to 6. GBA is quite a step up from CHIP-8. I would suggest doing NES or GameBoy next, but of course with today's LLM help GBA is very reasonable if you are going that route.

Ginop•about 4 hours ago

I misread Fem-Boy and I was not understanding the context anymore lol