sleep(); sleep(); sleep(); allTestsPass()

Hello everyone! Let’s dive in so I can get back to work before I go to bed!

Testing, Testing, 1, 2, 3

For the last couple hours, I’ve been writing unit tests for the ROM module.
I’ve been going on and off with unit tests for a while. Before, I wanted to write unit test for cpu instructions before realising Blarrg made test ROMs for that.
Because of that, test ROMs are the primary mode of testing out Riggurly, especially since test ROM developers know much more about specifics, like the halt bug, than I do.
However, trest ROMs don’t test things like saving and loading, which is something I CAN write tests for in a reasonable amount of time.

A lot of the work I’ve done was just making one helper function and figuring out what I wanted to be covered by it and what I want the tests to do. I might also refactor some repeated stuff into another helper for more efficient code after I finish writing the save round trip unit tests.

That’s it for now friends, and don’t forget to listen to Flavor Foley’s new album, Mirror Modulation, which dropped today? on all music streaming platforms

Little Bonuses

Hello Everyone! I have to go walk the dogs, so let’s dive right in!

Building Codes

Since I want a few more hours to try to see if I can get a Framework 13 and Celeste, I decided it would be good to add all the nicities I did for my last CLI, leading-zero-util (I know, terribly named), namely, man file and completion generation.
On lzu, I used a hidden flag for completions and had a build.rs for the man page. However, I found it best to merge all of them into one hidden flag for ease of use. At first I tried a build.rs, but it kinda made dependencies annoying and made either my or lib users’ lives worse.
That’s it for now folks! Next I’ll be working on unit tests for ROM stuff.

Much TODO About Nothing

Hello everyone! We are finally back after a devlog hiatus due to me having to write essays to apply for my school’s software team! Let’s dive in so I can work on my history homework!

Read It and Weep

Last time, I talked about, in one title line by accident, how writing documentation and documenting my software’s flaws really exposed what was wrong with it. This update is all about fixing those flaws (mostly)

A Multitude of Screams

One of the biggest issues with my emulator was the audio. Not in the backend, but the frontend. Due to laziness, I didn’t bother adding mono audio support, which ended up being a 5-minute fix.

There was also another glaring issue with the audio: Once it crashed, it wouldn’t rebuild the stream. If you unplugged your headphones, thinking the audio would continue on your other speakers, it would just turn it off and modulate speed with std:🧵 :sleep(). It took me a while to write all the rebuilding code in such a way to maximise user QoL for all users.

When did I download you?!

Since Riggurly is both a CLI AND a library, it has dependencies that are used only in the CLI that are still a part of the package as a whole. Library users still have to download and compile these dependencies, which can be a hassle and a waste of time.

I’ve been meaning to put CLI-only dependencies behind a feature so library users can easily prevent themselves from downloading and compiling a bunch of heavy extra dependencies. This also taught me how to use features, which was good.

You’re a Waste of the Air You Breathe!

One thing that’s been bugging me for a while is efficiency. My array for the fallback memory bus array in the memory bus struct has always been 0x10000 bytes long (1 mebibyte, how much ram a GB has (kind of)). How reading and writing has worked is that there are match statements you go through to see if you access that array or you access the rom or if you access the vram or something else. The problem is that over 3/4 of that array’s length is useless and shadowed by ROM/CRAM/VRAM. I was wasting 768 kb of heap-memory. I ended up dropping the first 3/4 and just having a smaller array. Unfortunately, some space is still wasted, but it’s not much compared to before. I showed @ElffawIThink and they though it was funny.

Also, one of the ROM types comes with 512 HALF-BYTES(nibbles) of RAM, which I had been representing with a [u8,512] with the upper nibbles of EVERY BYTE going unused. I shrank this down to a [u8,256] and use both nibbles for a fish in the sea.

Take Me Home

Before, I had to put a disclaimer in my README that you couldn’t use ~ as your home directory in your default ROM path in your config.toml because different users have different home directories and I have to use the dirs crate to find that out at runtime. This was a surprisingly long fix, though it was quite simple. Just a few lines of code to strip the ~ and replace it with the already found home directory.

That’s all for tonight comrades! Make sure to listen to Jamie Paige, especially Clover! That song is now the first song in my playlist with vocal (sequentially, obviously my playlist has other songs with vocals), overtaking Lemon Boy by Cavetown, it’s just that good. It has also shown itself to be a better daily anthem than Villain by Teniwoha and Schifty Five, the YouTube classic.

Lover Tell Me if You CanHello everyone! Let’s dive in so I can work on improving the user experience!## ManThis devlog is all about README. I have actually never used Markdown before, only org, Emacs’s outliner/md format, because it is more intuitive and Emacs gives you more toys. My style guide is in org, my todo lists are in org; the only things that aren’t are the AGENTS.md I stole from Ghostty and the README.md. I ended up using a combination of the Stardance and Phantom README guides to help me figure out what to put in it and how to do syntax. Working on the README put an emphasis on some flaws in my code:- config path ~ not expanding- my glaring lack of a homebrew tap- mono audio still being unsupported- feature gating on binary-only depsThat’s it for now folks!

Erroneous

Hello everyone! I have a history in-class-writing in 6 hours, so let’s dive right in!

Error 404

Once I started adding support for loading ROMs and saves, failure points became possible. I hadn’t previously written errors before, so I just wrote strings and propagated them through with Result< T, Box> and the ? operator, with no regard to API users that may want to recover from a failure. I’ve been putting this off for so long, and was even considering doing this after shipping, but since I have so much time on my hands and the only other big TODOs left are the README.md and the Homebrew tap, I decided, why not? This has been a very interesting process over all, and it even gave me the impetus to do some proper gating on load_rom. Different MBCs only support some cram sizes, but because I wasn’t gating on load, these would fail at runtime with a mismatch.

Read All About It

Next up is the README. I previously had a mediocre, small, incomplete README in a file formet I forgot crates.io doesn’t have a renderer for, so I figured it would be best to start from scratch in Markdown instead of trying to port it over from Org. I also chnaged the name to Riggurly since that rolls off the tongue more.

That’s it for this morning! I also found the bathroom in ENA: Dream BBQ, which was cool. I still need to go inside. Also, make sure to listen to Jamie Paige, as she always boosts my productivity!

Vendetta

Hello everyone! Let’s dive right in so I can work on my math homework so I don’t fail my calc test next week!

TUIzers

I COMPLETED THE TUIIIIII!!! I added a text entry box for people to manually enter the names of their new saves. I also stylised the highlighting a bit more, and , even though its not in the video, now, the color changes to green when you’re selecting a save. This was a really fun learning experience.

I originally wanted to make a TUI because one of the raters on my last project, leading zero util, complained about having to use a simple CLI and told me it wasn’t that good because of the lack of TUI, so this has been kind of a personal vendetta against that person to improve my software and user experience.

The Other Interface

This project isn’t just a CLI utility. The entire time I’ve been building this, I’ve wanted to enable others to make a frontend for it, whether it be on the web or a gui or some port of it in something. I’ve maintained a careful separation between lib and bin, with the exception that they are the same crate. For library users, dealing with my errors would be impossible since many of them are just strings and they are all just Box. Before throwing this on crates.io, I want to make error enums and stuff so people can do error matching.

Tap Tap

After completing error enums and stuff, I’m going to throw it on crates.io and make a github release so I can make a Homebrew tap. The last time I made a homebrew tap, I gave the project it’s own separate tap repo, but this time I’ll keep all my taps in a new tap repo on my GitHub instead of Codeberg for users.

That’s it for now! I’m excited to make error enums so I can have that skill under my belt as well! Also, I’ve reached the point where shipping would probably let me get a framework 12, which is very exciting for me.

Pick Me

Hello everyone! Let’s dive in so I can go feed my gecko and sleep!

Seleccionar

For the past few hours, I’ve been working on the file picker for selecting a rom and a save file. A lot of it is just learning about how to use Ratatui. Originally, I was going to have the selecting happen all at once, by one function, but I switched it to two calls so that load_rom() and has_battery() can be called to check whether the save menu should even come up.

Write-In Candidate

The thing is, since with a new save, the file has to be constructed by the emulator and it doesn’t exist. Right now, I’m writing a little text input field to be triggered if the save menu gets close with Esc. This will be pretty short, and won’t require a large change to existing code. After that, I’ll wire it in and test.

Next Steps

• Homebrew Cask
• Separating frontend from backend crate by crate, so lib users don’t have to deal with frontend only imports.

Ratatouille

Hello everyone, we’re back with another devlog! Let’s dive right in so I can hit bed so I can go rafting the day after tomorrow!

Compliance Chips

I’ve finally finished dealing with compliance! I’m surprised by how many extranneous parentheses I had! I knew I had a lot, but I didn’t know it was this much! I’m so happy that is over so I can get to real work!

Tui T. Sutherland

The last big feature I wanted to add before shipping was a TUI for selecting ROMs and saves. To do this, I need to use the ratatui crate, which fortunately run off the same crossterm my project already does.

So far, all I’ve done is learn about it and write the fn for getting the directories/files with the appropriate endings and sorting them for display use.

I’ll see y’all in a couple days!

Comply-cations

Hello everyone!! We’re back with another devlog today. Let’s dive right in so I can start the next step!

Parensal Issues

As I said in my last devlog, while working on compliance for joypad.rs, I realised that I needed to delete extra parentheses around operators with obvious precedence. After working on that file, I continued down the buffers open in Neovim, also correcting that issue in addition to the others.

Because I only caught it midway through, I have to complete a second pass of compliance editing. Fortunately, I have mini.surround installed, so deleting parentheses is really easy.

That’s all that really happened. Make sure to listen to the daily dose of Jamie Paige and Vane Lily’s new song!

You Will Be Terminated

Hello everyone! We’re back with another devlog! Let’s dive right in since it is 02:00 over here!

Lookin’ So Fab

I have contined with my quest to implement my BEAUTIFUL and living style guide.

Here’s what I did, since this work is mostly just repetitive and long.

• gpu.rs and memory_bs.rs publicity compliance.
  Before today, 4/6 of Gpu’s fields were pub(crate) something they had no business being, so I refactored so everything uses methods. Took a chunk of time but it was very worth it.

• registers.rs
  This one was pretty stupid. It had two main issues, publicity and masks.

The lackluster and incomplete guide I was following had me write registers.rs with a ton of bitmasks it didn’t need it in a way that was ugly and sad, so I dropped the masks.

All of Registers’ field and subfields are pub(crate), which I determined is optimal because it would be a major and massive chang to Cpu, and the registers are purely for the Cpu to use, and are part of the Cpu.

• rom.rs
  rom.rs was pretty chill, only a few things here and there.

• joypad.rs
  Despite this one taking a matter of minutes, this one is going to cause my so much work. All of its publicity was correct, as well as bit selecting formatting. Turns out I’ve been forgetting to remove parentheses around my files! Simply ridiculous!

ANyway, that’s all for now, since I need to go touch bed. So y’all later, and keep listening to Jamie Paige!

If You Do Not Comply

Hello everyone! We’re back with another devlog! I need to go to school soon, so let’s dive right in!

Numerics, Literally

Since I made the style guide, it was time to start implementing it. So far, I’ve gone through emulator.rs, memory_bus.rs, apu.rs, and cpu.rs.

• emulator.rs
  This one just needed doccomment formatting.

• memory-bus.rs
  This one needed a few numeric literal changes. I also directly accesses the stat field of gpu, which is unnacceptable, but since I’m doing gpu.rs next, I left it for the time being.

• apu.rs
  Despite being the file in which I came up with a chunk of my numeric literal style while writing, it felt like every literal was wrong.

• cpu.rs
  This was the second easiest file, despite it being the longest by a wide margin. There was some repetitive numeric literal issues in the methods, but that was it. I also tried to split it into multiple files for length since it is double the size of any other file, but I lowkey failed.

Next up is gpu.rs compliance. I’ll see y’all next time!

Dripmogging

Hello developer theme users! It’s been a couple days since my last devlog, since I couldn’t make one last night since my dad thought I had school today, so let’s dive in so I can work on compliance and becoming a peer tutor for math for my school!

Bitmasks: origins

One of the biggest parts of this project is working with bytes and getting data from bytes. To do this, you have to shift the bits you want to the end and then mask them like (byte >> shift) & bitmask. I feel like I’ve gone through dozens of different styles for bitmask and shift numeric literals, which is where the whole style guide idea came from.

Personal Stylist

For the past 4 hours, I’ve been perfecting a style guide for my codebase. It’s a beautiful org doc with that sweet sweet table of contents with rules on everything from numeric literals to tests to error enums. There’s not to much to say except the next step is going over all 5000+ lines of code to enforce compliance.

I’d like that written up

A quick note on org. Many online code hosting services like GitHub and Codeberg support org rendering. Rather unfortunately, crates.io only supports a README.md, and not a README.org, which gives me a big sad, especially since I’ll haveto rewrite my README in markdown (ew), which does not give me the luxury of an automatically generated table of contents.

That’s it for now folks, see y’all tonight!

Scream it Loud and Scream it Proud

Hello everyone! We are back with the once again DAILY devlog!!! Let’s dive right in!

IT LIIIIIVES!!!

This morning, as soon as I came up, I sat my @ down to trouble shoot my audio processing on 4 hours of sleep . Despite adding the manual sleep time reduction, I was still experiencing some crackling, so I found a bug in the channels, solving which didn’t solve anything, but switching timing to be based off of audio when available worked like a charm, giving better and more accuracte speeds and crisp audio, so I was able to show off my COMPLETED EMULATOR CORE to some of my friends (as well as my backpack with Ferris on it).

IT DIIIIIES!!!

After adding the audio, I had to make sure that it wouldn’t cause the emulator to break, so I added a timeout that shuts off audio if it’s broken for more than 500 ms

YES CAAAAAAP

Because of how I was translating from u16 audio to f32, I was getting popping, so I implemented a software capacitor to slowly dampen sounds closer to EQUILIBRIUM

SWITCH IT UUUUP

After audio had all it needed, it was time to work on something I had long anticipated, a lib.rs for people o build their own frontends on top of my emulator. I also added an Emulator wrapper struct around Cpu so that it would be easier to manage pub methods and such without the ~1550 other lines in cpu.rs making things hard. There’s a reason this project isn’t just one big file of 5000 SLoC.

I also added some documentation, and I found the best use of Claude Code is checking for spelling errors (it’s like I’m illiterate!)

Speaking of SLoC, I cracked 5000 today! This is about 3.5x larger than my last two projects combined! I’ll see y’all next time, and don’t forget to listen to beabadoobee’s new album Pylon and Jamie Paige!

BLAAALAKKLJHSLJHDKHJALKJHLKGSFG

Hello everyone! It seems that the devlogs have become oppositely bidaily — just this once, don’t you worry — than my last two devlogs. Let’s dive right in since we have so much to cover.

audio output master race

After I finished chan 4, it was time to implement master apu registers and channel mixing and panning.
Most of the registers were pretty simple, except the one with the master APU power on/power off, as to implement it I had to gate every write on whether it was on, except the wave RAM. I also did that during my PE class (while exercising, of course), which contributed to the difficulty. Fortunately, I write my code in Neovim, so it really sped things up, including 1-handed editing.
With that, the backend was nearly done, and I had reached the point at which I would no longer need Pan Docs or anything of the like, just straight Rust sailing.

Thread the Needle

In order to get the audio timed correctly, I had to hook up tick_channels() to a channel on which it sends a tuple of u16s (left and right amplitudes) to some receiver. This lets the audio be decoupled from whatever frontend one has.

Your Pal, CPAL

cpal is a a Rust crate for audio and stuff. Here’s the audio stuff because I can’t think straight it’s so late & I have an integration by parts quiz tomorrow and I don’t want to fail something light b/c I didn’t sleep.

fn get_audio_stream(cpu: &mut Cpu) -> Result<Option<Stream>, Box<dyn std::error: :Error>> {
    if true && let Some(device) = cpal::default_host().default_output_device() {
        let supported_stream_config = device.default_output_config()?;
        let stream_config = supported_stream_config.config();
        let sample_format = supported_stream_config.sample_format();
        let (sender, receiver) = std::sync::mpsc::sync_channel::<(u16, u16)>(5000);
        let error_callback = |_err: cpal::Error| {};

        cpu.set_audio_sample_rate(stream_config.sample_rate);
        cpu.set_audio_sample_sender(sender);

        let stream = match sample_format {
            cpal::SampleFormat::F32 => {
                let data_callback = make_data_callback::<f32>(receiver, stream_config.channels);
                let stream = device.build_output_stream(
                    stream_config,
                    data_callback,
                    error_callback,
                    None,
                )?;
                stream.play()?;
                Some(stream)
            }
            cpal::SampleFormat::I16 => {
                let data_callback = make_data_callback::<i16>(receiver, stream_config.channels);
                let stream = device.build_output_stream(
                    stream_config,
                    data_callback,
                    error_callback,
                    None,
                )?;
                stream.play()?;
                Some(stream)
            }
            cpal::SampleFormat::U16 => {
                let data_callback = make_data_callback::<u16>(receiver, stream_config.channels);
                let stream = device.build_output_stream(
                    stream_config,
                    data_callback,
                    error_callback,
                    None,
                )?;
                stream.play()?;
                Some(stream)
            }
            _ => Err(
                "Audio output sample format not supported! Try disabling audio in your config with 'audio = false'",
            )?,
        };
        return Ok(stream);
    }
    Ok(None)
}
// makedatacallback not shown due to char limits

Position,Velocity, Acceleration, Jerk, Snap, Crackle, and Pop

After that, I tested it, but there was some terrible audio crackling. Turns out it was due to oversleeping when trying to time things correctly, though before finding this out, I ended up slightly optimising draw_frame().The artifacts seem to be mostly gone and I will leave this to tomorrow silly. nearly @ 5000 sloc

Madra Channels

Here we are; we’re back again, making this a bidaily devlog?! Let’s dive into the last 1½ hours of development so I can touch bed.

Me-Chan Navigator

After finishing channel 4, it was time to tackle the most complicated (maybe, but 4 is pretty funky), or at least the weirdest.

I thought channel 3 varied it’s pitch based on the info in the wave ram, BUT NOOO, it varies the waveform instead. It let’s the gameboy make more varied sounds rather than just variations of beeps, like saw waves and stuff.

Lots of its machinery is reused from the other channels, and it also doesn’t have envelope because you can vary the volume yourself.

That’s it for this devlog! See y’all tomorrow as I probably will finish audio tomorrow!
I don’t think there is an applicable image for this, so have some xkcds

4Chan

Hello everyone! Welcome back to the Daily Devlog, where we go over the new developments in RustyGameGirl!! Let’s get started with today’s broadcast!

White Noise, Brown Noise, Black Noise, Grey Noise, What’s the Difference?

After finishing the two pulse channels, 1 and 2, it was time to start a new one. I went with channel 4 since it is the closest to 1 and 2 in terms of structure and simplicity.

Channel 4 is a randomised noise channel thingy, for stuff, like gunfire maybe? Here’s the summary from Pan Docs:

This channel is used to output white noise, which is done by randomly switching the amplitude between two levels fairly fast. The frequency can be adjusted in order to make the noise appear “harder” (lower frequency) or “softer” (higher frequency). The random function that switches the output level can also be manipulated. Certain settings can cause the wave to be more regular, sounding closer to a pulse than noise.

A lot of channel 4’s machinery is the same as 1 and 2’s, like envelope and length, which brings us to our next section.

Adaptive Water Body

Until today, I have never written a trait in Rust. I’ve used them, of course, especially Default and Drop, but also the num-traits crate from when I was making my fast-factor crate, but I’ve never written one before. I figured now was as good a time as any, especially since all four channels share many similar methods, like the nrxy reads and writes, output (to u8 only), clock_length, tick_period, etc., so I added the three following traits:

trait Channel {
    fn output(&self) -> u8;

    fn tick_period(&mut self, ticks: u32);
    fn clock_length(&mut self);

    fn nrx1_read(&self) -> u8;
    fn nrx2_read(&self) -> u8;
    fn nrx3_read(&self) -> u8;
    fn nrx4_read(&self) -> u8;

    fn nrx1_write(&mut self, byte: u8);
    fn nrx2_write(&mut self, byte: u8);
    fn nrx3_write(&mut self, byte: u8);
    fn nrx4_write(&mut self, byte: u8);
}

trait ChannelWithEnvelope {
    fn clock_envelope(&mut self);
}

trait ChannelSpecificFeature {
    fn nrx0_read(&self) -> u8;
    fn nrx0_write(&mut self, byte: u8);
}

Having all the separate impl blocks forced and ordered the same makes the code far more readable, and it’s not like this will slow the code, and it sped up the creation of channel 4 and will likely speed up channel 3’s creation.

Notes

Rather unfortunately, since I was coding piecemeal today and I was to lazy (probably b/c of the gudetama shirt I’m wearing), I didn’t start listening to music until ater I was done coding, while I was working on homework (English I think? It was the only real homework I had today since I did most of the rest in class), but a Polyphia song just popped up in my shuffle (Reverie), and I locked in so much harder.

Also, once I started working on the APU, I cracked 4000 SLoC!!! That’s more than my last two projects doubled and combined. It’s also likely the majority of code I’ve written in the 7 years I’ve been programming. I am currently at 4509 SLoC, which is over triple my last two projects combined!

See y’all tomorrow, if not later tonight!

Sweep It Under the Rug

Hello humans! We’re back with the DAILY DEVLOG!!!!! I need to go to bed and feed my geck, so let’s dive right in!

No Sweeping for You!

Today, I finished up last night’s work of finishing channel 2. All that was left was adding an output to u8 fn that’s just sitting there as dead code rn and wiring it up to read_byte(). relatively uneventful, except for when I forgot how bitwise operations work.

WeeeWoooWeeeWooo

After channel 2, the obvious next step was channel 1. Channel 1 is just channel 2 with an extra feature: sweep. Sweep is kinda funky. I thought it changes envelope, but it actually changes pitch. It does some weird funky shenanigans to change the pitch and also on note trigger. A lot of building channel 1 was just making echo fns for proper layering of structs. Pan docs was once again confusing.

Notes

A side note on documentation. While working, I decided to read the forword of pan docs, and lo and behold, its built for game developers, but there’s also a Complete GB Technical Reference which was supposedly built for emulator builders. I decided to check it out and see if it would be more useful than pan docs. BUT GUESS WHAT?? It had EVRYTHING EXCEPT AUDIO in there!! The word “audio” was used exactly once!! Apu wasn’t even mentioned!!! SO I have to continue with pan docs, which does have decentish detail for audio.

Music

I ended up listening to a lot of Chappell Roan, Cavetown, CITY LIMITS, and MAFUMAFU this session. Y’all should listen to the PEAK music of Sorry Ghost as well. See y’all next time!

Apu, like from The Simpsons?

Hello beautiful humans! We’re back, and I’ve finally stopped procrastinating on the APU! Let’s dive right in!

CPU, GPU, TPU, NPU, LPU, DPU, and now APU?!

I’ve been very scared of dealing with the APU, since it’s seemed like the hairiest thing to deal with, and it’s also the last part of the emulator core.

The APU has four channels and mixing and fading and stuff I will get into.

2 Chan

The first channel I started with was channel 2, since it is the simplest (1 has an extra feature, but otherwise, they’re the same)
There are four things one needs to understand for these channels:

• Period
• Duty
• Length
• Envelope

Duty is the waveform of the audio, like what percentage of the square wave is at level 1 vs level 0. This changes the timbre of the sound.

Length is the amount of time the note plays for. It’s harder for devs to have to manually turn off the notes on their own b/c of timing.

Envelope is the fade in/fade out of the sound

Also, on channel 1, there is sweep, which changes envelope I think? I don’t know b/c Pan Docs is confusing for this (built for game developers it feels)

Aaaanyways, that’s it from me for now, as I have a history in-class writing test thing tomorrow and I’ve already hit my 2½ hour goal for the day.

Also, I was listening to Constant Companions and I realised I probably never listened to the album hard enough b/c “Clouddrop” is a lot more depressing than I remember, and I got ts on vinyl soo that’s something I will be embarrassed to tell my friends. Also, y’all should listen to Constant Companions to increase her listeners so that one day, Jamie can have her Paige again.

Blink Twice

Hello everyone! This is going to be a shorter devlog, so let’s dive right in!

NOOOOOOOOOOOooooooooo

When I set up the keypress handling a bit back, I wanted to use the default Retroarch keybinds so that anyone who had ever used Retroarch could use RGG without difficulty. The one discrepancy was that you only had to click escape one singular time to quit the emulator. I am no stranger to mistaken clicks, and today I realised this could be an issue for anyone who shares some of my clumsy tendencies. I figured it iwould be good to better copy Retroarch’s binds by making it so that you had to click Esc twice in quick succession to quit. A nice and easy change tha’s completion will probably force me to actually stop procrastinating audio/APU.

Anyyywayyy, y’all should listen to CityLimits, DeltaFey, and Black Polish. I feel all of their music is great for programming.

We’ll see if I can post another devlog today. ¡Adiós!

Frontman

Hello everyone! This will probably, maybe, be the shortest amount of time for a devlog, so let’s hop to it!

I’ll never let you go

Last night, I implemented the backend funtionality and started on frontend functionality, a ’lil bit. Over the past 30 odd minutes, I finished up the saver struct. I wanted to have Saver be have a custom drop impl, but that would require it to carry an immutable reference to the CPU through the running of the emulator, which would break ownership rules due to having to make a mutable reference to the CPU to step it.

What I did was I isolated the loop into a function and saved the return value to a variable, which gets propogated after the emulator attempts to save.

The video is of me loading in a save into Pokémon Red! Comment which theme you want me to show off next!