Sr. Content Developer at Microsoft, working remotely in PA, TechBash conference organizer, former Microsoft MVP, Husband, Dad and Geek.
165061 stories
·
33 followers

Turn your Raspberry Pi into a classic games machine

1 Share

Following the launch of The Raspberry Pi Guide to Retro Gaming and the recent special retro gaming issue of Raspberry Pi Official Magazine, we thought this Maker Monday was an ideal time to revisit the topic, which seems to be having a bit of a moment.

One of the most popular uses for a Raspberry Pi computer, retro gaming makes use of the hardware’s power and ability to run emulation software to replicate a wide range of classic consoles and computers: from NES to PlayStation 2, and ZX Spectrum to Amiga. It’s easy to get started by installing a specialist emulation OS such as Recalbox, RetroPie, Lakka, or Batocera.

While you can enjoy Raspberry Pi retro gaming with a standard keyboard and monitor setup, there are many ways to achieve a more authentic experience so you can pretend you’re living in the past! Here, we take a look at a wireless gamepad, a classic console-style case, a couple of ways to output analogue video (including one for Raspberry Pi Pico), and a mini arcade cabinet kit for two players. Insert coins to continue play…

Picade MAX

Pimoroni | £495 / $549

These bartop arcade cabinet kits seem to be getting ever larger. First there was the original Picade with an 8-inch screen, then a 10-inch version, and now we have this super-size 19-inch MAX model — back in stock in the Pimoroni store — which adds controls for a second player.

The IPS display has a retro-friendly 5:4 aspect ratio and 1280 × 1024 resolution, with vibrant colour and wide viewing angles. The robust arcade joysticks and buttons are connected to an RP2040-powered USB controller board, resulting in very low latency for the inputs. A separate audio board (also powered by RP2040) outputs stereo sound to the cabinet speakers and, at last, there’s a physical rotary volume control.

If you want to go further, you can add NVMe SSD storage, swap out the standard buttons for RGB LED-illuminated ones, and even add a Galactic Unicorn for marquee lighting. The controller and audio boards are also available separately, so you could use them (or the original Picade X HAT) as the basis for a custom-built cabinet.

Verdict

A bigger bartop arcade cabinet with plenty of upgrades.

Warning! Legal ROMs

When finding ROMs for your retro setup, please be cautious that you are not downloading from a site hosting software illegally. There are lots of legal ROMs available, including many modern ‘homebrew’ titles developed for classic hardware.

The Raspberry Pi Guide to Retro Gaming

Raspberry Pi | £19.99 / $24.99

The easiest way to get started with retro gaming on your Raspberry Pi is by bagging a copy of this book. As well as a step-by-step guide to quickly create your own Raspberry Pi-based home console setup, it features advanced tips and tricks to help you perfect the emulation experience with hardware upscalers, dedicated video converters, and even vintage CRT displays for ultimate authenticity. The book also explains where to find legal ROMs, how to play your old floppies and CDs, and how to get games running from online stores. 

In-depth tutorials cover building the arcade machines of your dreams, including a pocket handheld for gaming on the go, and emulating 8-, 16- and 32-bit classic computers such as the Apple II, Atari 400/800, BBC Micro, ZX Spectrum, C64, Amiga, Atari ST, and IBM PC.

For those readers who don’t just want to play, there’s a chapter on classic 8-bit BASIC programming, including creating a full ZX Spectrum game — now that takes me back!

Verdict

A comprehensive guide to retro gaming on Raspberry Pi.

RGB Dual 2 

Recalbox | From €72 / £62 / $83

As well as providing a free and open source emulation system for Raspberry Pi, the Recalbox project has an online store in which it sells various bits of retro-related hardware. One of these is the RGB Dual 2, a Raspberry Pi 5-compatible board with analogue video outputs to connect it up to an old TV or monitor.

Fitting on Raspberry Pi 5’s GPIO header, and matching the SBC’s dimensions, it features four outputs: SCART, composite RCA, VGA, and a 3.5mm audio/composite jack. So your connection options are well covered, and it supports 4:3 and 16:9 TVs. Four DIP switches enable you to alter settings, such as forcing 50Hz mode and enabling 31kHz/Multisync. It also has a built-in I2S digital-to-analogue converter (DAC) for high-quality analogue audio.

You can buy the RGB Dual 2 board on its own or in a kit with various extras, such as a RecalTower stacking case. Either way, an Active Cooler is recommended to keep Raspberry Pi chilled as you enjoy pixel-perfect video.

Verdict

The easiest way to output analogue video to a TV or monitor.

Raspberry Pi Compatible Wireless Gamepad / Controller

The Pi Hut | £14 / $19

For console gaming, you’ll want a suitable controller, whether it be a gamepad or arcade-style joystick. There are countless options available, in a wide variety of designs, typically based on classic console controllers.

Most of them can be plugged directly into a standard USB-A port. This one, however, is wireless (powered by three AAA batteries). Instead of using Bluetooth like some other gamepads, it has a USB receiver dongle with which it communicates via 2.4GHz wireless — no extra setup required. As with any other controller, you may need to map the buttons in your chosen emulation software.

Resembling a classic PlayStation DualShock gamepad, it features an Analog button to press to enable full analogue thumbstick control (otherwise they just acts as buttons). There’s also a Turbo button for rapid fire — great for shoot-’em-ups. There’s no noticeable wireless lag, either.

Verdict

A good value-for-money wireless controller.

Game 5Pi Retro Gaming Case for Raspberry Pi 5 

52Pi / The Pi Hut | £17 / $23

When playing emulated games, you might want to add a vintage-style case to enhance the illusion that you’re back in the eighties, nineties, or whenever. There are many cases resembling classic consoles available, such as the PlayStation, Dreamcast, SNES / Super Nintendo, N64, and Game Boy. This one harks even further back with its boxy NES-like design, albeit a lot smaller than the real thing.

To help prevent your Raspberry Pi 5 overheating, it features excellent cooling with two fans: one mounted on Raspberry Pi with thermal pads, and a second ‘exhaust fan’ blowing air through the vents in the case.

The two-part case is easy to assemble, and there are cutouts for micro HDMI and USB-C power ports, plus a microSD card slot. A hinged flap can be lifted to reveal the USB and Ethernet ports. Unlike some cases we’ve seen, the two buttons on the front are non-functional, but there is a tiny one at the rear to press Raspberry Pi 5’s own power button.

Verdict

As well as looking cool, this classic case has excellent cooling.

Pico VGA Demo Base

Pimoroni | £20 / $22

While not as powerful as a full-size Raspberry Pi computer, a Raspberry Pi Pico can emulate many classic 8-bit consoles and computers. The biggest issue is outputting video and audio. You could opt for Pimoroni’s PicoVision, which outputs hi-res video via an HDMI port. The downside is that it won’t run standard Pico-based emulators unless you adapt them to use its hardware.

The Pico VGA Demo Base is a simpler option for Pico-powered emulation on a VGA monitor. Compatible with Raspberry Pi Pico and Pico 2 models, it has its own micro USB power port (freeing up Pico’s own for USB devices), a microSD card slot for storage, and two 3.5mm audio jacks (for DAC and PWM).

You can flash the RP2040 version of the classic Doom, created by Raspberry Pi’s own Graham Sanderson, or use one of the Pico-based system emulators available. Some, like pico-zxspectrum, even have precompiled UF2 files for the VGA Demo Base; others can be compiled with an option to use the board’s pin mapping, etc.

Verdict

An easy way to output VGA video from Raspberry Pi Pico for retro gaming.

8BitDo Retro Mechanical Keyboard

8BitDo / The Pi Hut | £90 / $121

When emulating classic computers, it’s worth connecting a mechanical keyboard with old-fashioned clicky-clack keys. This one features an 87-key layout with Kailh Box White switches V2 for tactile typing. It comes in four retro colour schemes: C64, N, Fami, and M. 

Get your copy of The Raspberry Pi Guide to Retro Gaming for £9.99

This book shows you all the tips and tricks you need to start playing all your favourites from yesteryear. Retro gaming enthusiasts love Raspberry Pi for how easy it is to use for their retro games, especially when they can do it all on one device and not need a roomful of consoles and computers like in the 80s and 90s.

Inside you’ll find information on how to create a simple, quick setup to relive the glory days of gaming, along with more advanced tips on achieving the perfect emulation machine thanks to advanced techniques, hardware upscalers, and dedicated video converters. There’s a lot of devices and extra tips that you’ll find in here, from finding or making the right controller to connecting older peripherals to your Raspberry Pi.

Our step-by-step guides also include how to create a nifty pocket handheld for retro gaming on the go, and a full-size arcade machine to maximise your nostalgia. All this, and we’ll also show you where to find legal ROMs, play your old floppies and CDs, and get games running from online stores.

The post Turn your Raspberry Pi into a classic games machine appeared first on Raspberry Pi.

Read the whole story
alvinashcraft
18 minutes ago
reply
Pennsylvania, USA
Share this story
Delete

James Shore: Assessing the Impact of AI - Episode 428

1 Share

https://clearmeasure.com/developers/forums/

Today's guest is James Shore, author of The Art of Agile Development and a consultant who transforms software development organizations when repeated fixes have failed. James is a recipient of the Gordon Pask Award for Contributions to Agile Practice, an early adopter of Extreme Programming, and previously served three years as VP of Engineering at OpenSesame. James last joined me in 2021 to talk about the second edition of The Art of Agile Development, and I'm glad to have him back to learn about his most recent project.

Website - https://www.jamesshore.com/
Biography - https://www.jamesshore.com/v2/services/biography
Blog - https://www.jamesshore.com/v2/blog
The Art of Agile Development - https://www.jamesshore.com/v2/books/aoad2
Are You Getting Your Money's Worth - https://www.jamesshore.com/v2/blog/2026/are-you-getting-your-moneys-worth-from-ai
Assessing AI Impact Notes For Your CFO https://www.jamesshore.com/v2/blog/2026/assessing-ai-impact-notes-for-your-cfo LinkedIn - https://www.linkedin.com/in/james-shore-7475b6/ Mastodon - https://mastodon.online/@jamesshore Github - https://github.com/jamesshore

Previous episodes with James Shore:
Episode 167 - https://azuredevopspodcast.clear-measure.com/james-shore-on-the-art-of-agile-development-episode-167

Want to Learn More?
Visit AzureDevOps.Show for show notes and additional episodes.





Download audio: https://traffic.libsyn.com/clean/secure/azuredevops/Episode_428.mp3?dest-id=768873
Read the whole story
alvinashcraft
18 minutes ago
reply
Pennsylvania, USA
Share this story
Delete

541: .NET 11 Launch: Performance Gains, Union Types, and Runtime Changes

1 Share

James and Frank dive into .NET 11's biggest announcements from .NET Conf 2026, exploring the performance optimizations that matter most to developers—from native AOT CLI tools shaving milliseconds off startup times to runtime async improvements that make your code faster without changes. They break down union types, MAUI's runtime consolidation, and why the team is obsessed with squeezing every millisecond for modern development workflows.

Chapters

  • 00:00 Welcome and Studio Setup Chat
  • 01:13 .NET 11 Launch and .NET Conf
  • 02:52 Building the .NET Conf Q&A Platform
  • 09:17 Performance Optimizations and Native AOT
  • 13:54 Runtime Async Preview Feature
  • 18:33 Union Types and Type Safety
  • 23:25 MCP Servers and AI Integration
  • 25:40 MAUI Runtime Consolidation and Mobile
  • 31:12 Feature Roundup and Community Engagement

Links

Follow Us

⭐⭐ Review Us ⭐⭐

Machine transcription available on http://mergeconflict.fm

Support Merge Conflict

Links:





Download audio: https://aphid.fireside.fm/d/1437767933/02d84890-e58d-43eb-ab4c-26bcc8524289/27c755a7-9dae-4c3b-9dfb-d73027e46c28.mp3
Read the whole story
alvinashcraft
18 minutes ago
reply
Pennsylvania, USA
Share this story
Delete

Setting a spending limit on a Claude Code session

1 Share

An agent that runs on its own stops when the task is done, not when your budget is. That’s fine for a quick question, but it’s a different story for a refactoring job in CI or a scheduled run overnight.

So the question becomes: how do you put a ceiling on a Claude Code session?

Remark: Strictly speaking you can’t set a token limit. Claude Code caps on spend (tokens × price), so that’s what we’ll use.

The naive approach

Just run it and see what happens:

claude -p "Run the test suite, fix the failing tests in src/ and commit the fix"

There is no limit by default. Claude keeps going until it thinks it’s finished, and you find out the cost afterwards.

Two flags can help

Claude Code has two flags that act as a safety net in print mode (-p):

claude -p "Run the test suite, fix the failing tests in src/ and commit the fix" \
  --max-budget-usd 3.00 \
  --max-turns 30
  • --max-budget-usd stops the run once the estimated spend on API calls reaches the amount.
  • --max-turns limits the number of agentic turns. When the limit is reached, the run exits with an error, so your script can branch on the exit code.

I typically use both. A runaway loop that keeps retrying a failing fix hits the turn limit long before it gets expensive, and the budget flag covers the case where every turn is just very large.

Remark: The budget is a soft cap. It’s checked against a client-side estimate that can differ from your actual bill, and spend can pass the cap. Best to leave some headroom.

What about interactive sessions?

As far as I know, there is no equivalent hard cap for an interactive session. What you can do:

  • Check the running cost with /cost.
  • Look at what is filling your context window with /context.
  • Use /compact to summarize a long session, or /clear when you switch tasks.
  • When you’re billed through the API, set a spend limit on the workspace in the Anthropic Console as the backstop.

That’s it! Set both flags on every unattended run and treat the result as a safety net, not an exact meter.

More information

Read the whole story
alvinashcraft
19 minutes ago
reply
Pennsylvania, USA
Share this story
Delete

Uno Platform 7.0 Adds WebGPU Backend, Apple TV and Reactor Support, and Retires Native Rendering

1 Share

Uno Platform 7.0 unifies rendering on SkiaSharp 4 with an opt-in WebGPU backend, adds Apple TV as a target and supports .NET 11 from day zero. It also runs third-party .NET MAUI controls and Microsoft.UI.Reactor on all targets, and removes native rendering and Mac Catalyst.

By Edin Kapić
Read the whole story
alvinashcraft
19 minutes ago
reply
Pennsylvania, USA
Share this story
Delete

Worse is better: async/await versus syntactic sugar for monadic composition

1 Share

A missed opportunity masquerading as a killer feature.

This article is part of a series called Worse is better, in which I muse on technologies and techniques that became popular despite superior alternatives. Think VHS versus Betamax.

In this article, I will argue that the celebrated async/await language feature pioneered by C# should rather be classified as a missed opportunity. F# did async first, and better, but of course Haskell does monads even better.

Since the introduction in C# the async and await keywords have been ported to multiple other languages, including C++, Python, JavaScript, and more. With such apparent success, it seems odd to complain that it's worse than alternatives.

My Richard-Gabriel moment #

To be honest, async/await is perfectly cromulent. Pragmatically it solves real problems. What's the complaint?

As examples go, this is perhaps the most direct counterpart to Gabriel's original lament about C++ and Lisp. Gabriel considered Lisp superior to C++ because Lisp was a coherent and elegant system. Still, the heterogeneous hacked-together nature of C++ enabled faster time to market, eventually outcompeting Lisp.

Adding async and await keywords to a language is comparable to the C++ approach. Instead of solving a general problem, it only solves a particular problem, albeit a large one.

Computation expressions #

What makes this so regrettable is that a general language-design solution already existed. As witnessed by language version history, F# already had asynchronous workflows with syntactic sugar in 2007. This language feature still exists today:

member _.GetRecommendationsAsync userName = task { // <- async
    // v await
    let! scrobbles = songService.GetTopScrobblesAsync userName

    // The rest of the code block follows...

This example is from Porting song recommendations to F#, although I've clipped the code and changed the comments for didactic reasons.

The language feature is called computation expressions, and while the base library comes with a few built-in computation expressions, it's a completely user-definable feature. My article Song recommendations with F# free monads has a comprehensive example, but usually, a few lines of code are enough.

The original 2007 computation expression was called async, and it's still around. Since it predated the .NET Task Parallel Library, it was based on its own implementation of Async<'T>.

Later, the F# core library also got task expressions to support the de-facto standard of using Task<T> for asynchronous processing. No new language feature was required.

In the above code example, task introduces the computation expression, roughly corresponding to the C# async keyword. Likewise, the exclamation point ! in let! corresponds to await. The beauty of the F# language design is that while it perfectly supports asynchronous programming, it's by no means specialized to that task.

Short-circuiting workflows #

Computation expressions can add syntactic sugar for any functor, applicative functor, or monad, although you get the most bang for your buck with the latter.

For example, you can write short-circuiting workflows if you add a little computation expression builder for the option type. For instance, you could rewrite Cpr.tryParse from the article Danish CPR numbers in F# to something like this:

// string -> CprNumber option
let tryParse (candidate : string ) =
    let canonicalized = candidate.Trim().Replace("-", "")
 
    option {
        let! dayString               = canonicalized |> String.trySubstring 0 2
        let! dayCandidate            = dayString |> Int.tryParse
 
        let! monthString             = canonicalized |> String.trySubstring 2 2
        let! monthCandidate          = monthString |> Int.tryParse
 
        let! yearString              = canonicalized |> String.trySubstring 4 2
        let! yearCandidate           = yearString |> Int.tryParse
 
        let! sequenceNumberString    = canonicalized |> String.trySubstring 6 4
        let! sequenceNumberCandidate = sequenceNumberString |> Int.tryParse
 
        return! tryCreate
            dayCandidate
            monthCandidate
            yearCandidate
            sequenceNumberCandidate
    }

This workflow may fail at every step marked by an exclamation point. If it does, it stops processing the rest and simply returns None.

This behaviour didn't require a new keyword, or any new language feature, but instead relies on the general-purpose computation-expression language feature and, in this case, a little user-defined expression builder:

type OptionBuilder () =
    member _.Bind (x, f) =
        match x with
        | Some v -> f v
        | None -> None
    member _.Return x = Some x
    member _.ReturnFrom x = x
 
[<AutoOpen>]
module OptionBuilder =
    let option = OptionBuilder ()

While this is already quite elegant, it still requires a bit of (reusable) boilerplate for every functor you wish to support, such as option, result, task, etc.

Programmable semicolons #

Haskell, with its more powerful type system, fully automates this process. Every Monad (or Applicative with the ApplicativeDo extension) instance enables you to drop into do notation, which gives you nice syntactic sugar for the monad in question.

Since Maybe is a Monad instance, you don't have to write any user-code equivalent to the above OptionBuilder. Just drop into do notation, and the compiler automatically handles the workflow for you. As an example, you could port the above tryParse function to Haskell like this:

tryParse :: String -> Maybe CPRNumber
tryParse candidate =
  let canonicalized = filter (/= '-') $ trim candidate
  in do
    let (dayStr, rest1) = splitAt 2 canonicalized
    let (monthStr, rest2) = splitAt 2 rest1
    let (yearStr, rest3) = splitAt 2 rest2
    let sequenceNumberStr = take 4 rest3
    day <- readMaybe dayStr
    month <- readMaybe monthStr
    year <- readMaybe yearStr
    sequenceNumber <- readMaybe sequenceNumberStr
    tryCPRNumber day month year sequenceNumber

All the variables bound by <- arrows may cause the computation to short-circuit. This syntax is equivalent to F# let! bindings. Returning a short-circuiting value is also possible in both cases, but while F# requires the return! keyword, in Haskell this is done by omitting return.

This Haskell language features is so powerful that Real World Haskell (among other sources) calls it 'programmable semicolon'. You could use the same phrase for F# computation expressions.

Where C# falls short #

The async/await feature of C# provides syntactic sugar similar to F# computation expressions and Haskell do notation, but unfortunately, only for asynchronous workflows. As long as your 'outer' monad is Task<T> it works decently, but it doesn't address other cases, like the above examples of short-circuiting computation.

Ironically, C# has another language feature that enables syntactic sugar for monadic workflows: Query syntax (AKA LINQ). You can see a small example in the Maybe monad article, as well as plenty of other articles on this site. You could port the above CPR example to C# and achieve short-circuiting behaviour using query syntax.

Is it possible to use query syntax with asynchronous workflows too? Yes, indeed, since asynchronous computations are also monadic. Is the async/await language feature redundant, then?

No, because query syntax has other limitations.

Venn diagram of computation expressions showing overlap between LINQ and async/await. Both support sequential composition; LINQ uniquely emphasizes extensibility, while async/await uniquely includes branching and commands. Parallel composition is shown as part of computation expressions in general, but is not a member of neither LINQ nor async/await.

As this diagram attempts to capture, while LINQ works for any monad (any functor, in fact), it supports neither branching nor Commands. That is, you can't use if or switch inside of a LINQ query, and you can't call void methods. You can see an example of the kind of trouble the latter issue causes in my Preserved in translation video. Another example of the awkwardness of LINQ can be seen in the article Flattening arrow code using a stack of monads.

On the other hand, as already covered, async/await does support branching and Commands, but is not user-definable; it only works for asynchronous workflows.

Finally, while both support sequential composition (monadic bind), none of them support 'parallel' composition, which is what you can get by ignoring monads and instead emphasising applicative functors. By 'parallel' I mean that you can compose independent computations in a way where what happens to one computation does not short-circuit the rest of the composition. This is particularly useful for validation, as shown in An F# demo of validation with partial data round trip. More specifically, it can be used to implement true parallelism, as demonstrated by the Haskell async package.

Language design versus implementation #

To be clear, my gripe about async/await is about programming-language design. Given the language design choice, the C# (or rather: .NET) implementation of async/await is impressive. Clearly, a lot of work has gone into making it work efficiently.

People who know how async/await and the Task Parallel Library works may consider the async package primitive at best, and possibly cheating. As far as I can tell, the Haskell async package creates a new thread every time you enter an Async computation. This can be expensive, and may not be necessary.

A C# Task, on the other hand, may or may not run on a separate thread. Often they utilize thread pools and relinquish threads back to a pool while waiting for external I/O events. A lot of thought has gone into the implementation, and my experience is that it works well. The Haskell async package does none of that, as far as I can tell.

The F# task computation expression, however, is simply syntactic sugar over the .NET implementation, thereby demonstrating that you can get the best of both worlds. A sophisticated, efficient implementation controlled by elegant and extensible language design.

Conclusion #

C#'s async/await language feature is so celebrated that other languages have adopted it. Even languages with little or no connection to Microsoft, such as Python and JavaScript, have a similar feature, sometimes even using the same keywords. Surely, this is a sign of success?

The async/await language feature is, in my eyes, a perfect example of Gabriel's maxim that worse is better. It's an essentially ad-hoc addition by way of adding more keywords to an already-complicated programming language.

What makes this disappointing is that a more elegant language design was already known at the time. C# could have got its own version of F# computation expressions, which would have enabled both language designers and 'normal' programmers to solve many more problems using the same, universal tool.

Of course, since C# already has two competing, partially overlapping kinds of syntactic sugar, I can't rule out that one day, it'll get a third, proper language feature that solves this once and for all. But I don't really believe that. That ship has sailed.

Which only underscores the message from the previous article: F# is a better programming language than C#.


This blog is totally free, but if you like it, please consider supporting it.
Read the whole story
alvinashcraft
19 minutes ago
reply
Pennsylvania, USA
Share this story
Delete
Next Page of Stories