byuu

hiro (https://gitlab.com/higan/higan/tree/master/hiro) by byuu (http://byuu.org) is similar to libui in that it wraps native controls. It isn't quite stable but it's very interesting. I love the simplicity of the API.

Personally, I have been using byuu's user script for this. I also love it for the click tracking removal and display of the complete url. https://byuu.org/projects/google

If you found this interesting, the author's website has a number of informative, in-depth articles about emulator development & console architectures: https://byuu.net/

My favorite bragging point: the code in the necdsp folder (and the CPU core itself at component/processor/upd96050) there was used by Stephen Hawking when they emulated his old voice machine that used the same chip. http://pawozniak.com/emulator/ Pretty cool that the same NEC uPD772x chip was shared between a text-to-speech engine and Super Mario Kart. If you want to know everything there ever was to know about the chip, I mirrored every PDF datasheet I could find on it on my site: https://byuu.net/datasheets#uPD7720 It has one of the most wild ISAs I've ever encountered, using a strict Harvard architecture and 24-bit VLIWs (very long instruction words.) Every opcode can do over a dozen different things in the same instruction at the same time. Writing code for it is quite the challenge.

They do, absurdly enough. See for example BSNES, https://byuu.org/ , here's a quote from their most recent release notes: "If the coprocessor firmware is missing, bsnes will fallback on HLE where it is supported, which is everything other than SD Gundam GX and the two Hayazashi Nidan Morita Shougi games." See past HN submissions about the extreme lengths BSNES goes to in order to get this data: https://news.ycombinator.com/item?id=3675123 , "In order to extract these programs from most of the DSPs, we had to decap the chips, scan them in with an electron microscope, and 'tweak' the processors to allow us to dump their protected program ROMs."

The day of the first, "lost package", and receiving the letter are the same: February 14th. https://byuu.org/emulation/preservation/lost-package/: As of the time of writing, February 14th, 2017 — this package has yet to arrive. https://byuu.org/emulation/preservation/found-package/ On February 14, 2017, I received the following letter from USPS: They totally left out this when making their initial post. Part of the package arrived, with a letter by USPS - the package didn't mysteriously vanish. It's a little different story. I don't know why they wouldn't have mentioned it. In the initial story, he blamed USPS for being incompetent on taking control of the delivery; in the second he blames Deutsche Post for a bad packaging job.

Actually, there is: https://en.wikipedia.org/wiki/Setcontext A library I personally recommend, which supports several platforms and back-ends: http://byuu.org/library/libco/

Also to note, the most accurate available SNES emulator is byuu's "bsnes", which is meant to be an archival-quality SNES emulator. Although it looks like now it's called "higan" since it supports more systems than just SNES. http://www.byuu.org/

This related article on accurate hardware emulation by byuu is great: http://byuu.org/articles/emulation/snes-coprocessors The process required an electron microscope!

I thought i recognized the name. This guy has his own emulator aswell. http://byuu.org/

Byuu is one of my hacker heroes. He's passionate, opinionated, and dedicated. The steps taken to map out the SNES, and make bsnes accurate makes it one of my favorite non-library open source projects. I highly recommend checking out his emulation articles on his site[1], and also his piece on ars [2]. [1] http://byuu.org/articles/ [2] http://arstechnica.com/gaming/2011/08/accuracy-takes-power-one-mans-3g…

Great stuff! I found myself missing a bit of background, though, which you can find here: http://byuu.org/articles/emulation/decap

At the hardware level, the author of BSNES recently wrote up an excellent rant on sources of latency in modern machines https://byuu.org/articles/latency/ But, most of what you are talking about is software latency. At 1/30th of a second each, software pipelining systems seem cheap individually but pile up very quickly. Hit a button, read the button, react in AI, react in animation, react in physics, react in graphics, process in the GPU, process in the display device. These can easily add up to 5/30ths of a second with poorly planned software. In the middle of all that, the animation and audio has aesthetic requirements for smooth transitions that can insert a 1/2 second lag in the middle of that process. Now we're up to 20/30ths. Regarding animations: I've been in convos with managers requesting character animations to be "Smoother, but more poppy!" because of the conflicting needs of aesthetics and control latency. The best compromise I've found is to design a smooth transition, but have the underlying representation pop and the visuals skip immediately to mid-way through the animation.

>How long is the list of games that zsnes doesn't have 100% accuracy Plenty of popular games. http://board.zsnes.com/phpBB3/viewforum.php?f=16 Notably, Yoshi's Island glitches out to the point of unplayable-ness in around half a dozen levels under ZSNES, the first one being 'Touch Fuzzy Get Dizzy'. This is the most high profile example. bsnes is the only emulator that lets you play yoshi's island properly, which happens to be many people's favourite game on the platform. The problem is down to some games exploiting timing tricks in the graphics subsystem to achieve transparency-like effects and so on. All the emulators apart from bsnes compute the graphics line-by-line, which breaks these tricks. bsnes draws it's output pixel-by-pixel, like a real snes, which is much more computationally intensive. "The reason is because while a scanline renderer runs at a mere ~15.75khz, a clock-based renderer would run at ~10.75mhz. That may not seem like a lot, but when you are writing an emulator that claims absolutely flawless interprocess communication, that means synchronizing two separate processors over ten million times a second."[1] All that context-switching makes your processor mad. The main reason for bsnes is homebrew snes developers' need of a bit-for-bit accurate snes emulator. These people need an emulator that will help them test code they are planning to flash to a cart and run on a real snes. ZSNES and other emulators designed to simply run commercially produced…

Went to look to look for this library. Looks like the website for that project is gone: https://byuu.org/library/libco/ So unless there is an authoritative mirror somewhere I can't tell you.

Bit perfect cd archival tool; extracts all possible non-track data (lead-in/out, subcode, ecc data, etc.), while losslessy compressing audio and meta into a single archive file per disc. Enables binary reconstruction of discs down to the etm layer. Sort of like a losslessy compressed bcd format proposed by byuu at: https://byuu.net/compact-discs/structure/

>audio CDs which I've found don't use checksums or other mechanisms to prevent small defects from mangling the bitstream Redbook audio CDs does use CIRC error correction, by storing 8 bytes of parity data inside each 33 byte F3 frame. It is not enough to correct all errors though, and Yellowbook data CDs stores extra correction codes on top of it. (276 bytes for each 2352 byte sector). (and there's also issue below F3 frame level about EFM modulation, whether merging codes are generated properly to keep DSV low enough) See: https://byuu.net/compact-discs/structure/ https://john-millikin.com/%F0%9F%A4%94/why-i-ripped-the-same-cd-300-ti… https://john-millikin.com/%F0%9F%A4%94/error-beneath-the-wavs

The author of this article is the creator of the bsnes SNES emulator[1], which is surprisingly resource-intensive even as a native binary. Making it a PWA (via WebAssembly or asm.js or whatever) just isn't practical, at least with the current state of browser tech. [1]: https://byuu.org/bsnes

the owner of this repo also has some good blog posts about this topic, including an overview of some of the custom chips and their impact on the emulator they also maintain (bsnes) https://byuu.net/cartridges/boards

Do you use https://github.com/Tencent/libco or https://byuu.org/library/libco/ ?

A really good library that we use is libco[0], it supports different architectures and mechanisms. We use it extensively on Fluent Bit[1] to manage async IO network operations (epoll + coroutines). - [0] https://byuu.org/library/libco/ - [1] https://fluentbit.io

Conversedly, there's higan[1] (formerly bsnes), a multi-system emulator focused on accuracy, even if it's at the expense of speed. A very beefy current CPU is necessary to emulate the sfc/snes. [1] https://byuu.org/emulation/higan/

Yep, he seems to hint at that in his blog post, while mentioning that the sender chose the insurance value: https://byuu.org/emulation/preservation/lost-package/ "... when I went to return the first box of 100 games, I was surprised to learn that FedEx would only insure packages for up to $2499. Anything higher would require documented proof of value, and the faxing of many forms, which the retail employee I worked with had no interest in even contemplating."

Lots more info at https://byuu.org/emulation/preservation/lost-package/

I think you're looking for phoenix: http://byuu.org/programming/phoenix/ An example application using it, with the GTK backend: https://i.imgur.com/pW2Jl9q.png and the Qt backend: https://i.imgur.com/z6cC3rM.png The author (byuu) posts here, he might be able to answer questions.

bsnes is now distributed with / renamed to a project called "higan", which is a multi-system emulator. See: http://byuu.org/higan/

He's not only a redditor. He's the creator of "bsnes" http://byuu.org/bsnes/ http://en.wikipedia.org/wiki/Bsnes one the most powerful emulator.

In case anyone else is interested in the source of this quote: http://byuu.org/articles/emulation/snes-coprocessors It's a fascinating story.

My current builds do perform per-pixel synchronization of the CPU and PPU. It cuts the speed in half compared to scanline-based, and even that is only because I run the chips out-of-order until synchronization is absolutely required. It's needed by Air Strike Patrol to draw the plane's shadow, as seen here: http://byuu.org/bsnes/images/accuracy/air-strike-correct.png It also affects a lot of "line error" issues, but those are fairly easy to work around with a scanline-based renderer.