A heavyweight games industry veteran says he is building a fully European alternative to popular game engines from American and Chinese companies. Arjan Brussee shared the plans in an interview hosted by the De Technoloog podcast (Dutch), reports the Video Games Chronicle.

Dutchman Brussee has some serious games industry credentials. His stint at Epic Games was split over two eras, the first one, which saw him programming the Jazz Jackrabbit games in the 90s. Then, from 2018 to 2023, Brussee returned to Epic as the global director of product management for Unreal Engine. Between those eras, Brussee became the co-founder of Guerrilla Games from 2003 (Killzone franchise), and Boss Key Productions from 2012.

The Immense Engine, a European alternative

Most readers will be familiar with game engines like Unreal and Unity (the latter was founded in Denmark but relocated to San Francisco in 2009). Brussee reckons that a European game engine will rival these offerings and alternatives from the Chinese, but The Immense Engine will be “fully European-hosted, built by Europeans, and complies with European rules and guidelines.”

Having a Europe-first game engine could be a boon for 3D simulations in defense or logistics on the continent. If it is built to adhere to the aforementioned European rules and guidelines, this could broaden its adoption in big government and local government projects, too.

Work already is underway with The Immense Engine, and other than gaming, it is clearly being developed with practical representations of 3D worlds in mind. We recently reported on the Japanese local government using U.S. game engines for large civil engineering projects, so Brussee is thinking along similar lines.

There has to be an AI angle

Software coding and AI are inevitably going to be further intertwined going forward, and Brussee embraces rather than shuns this trend. In the podcast interview, he said he sees opportunities with the rise of AI, especially by making the most of fewer human resources.

“If you are smart and know how to put a good framework of AI agents to work, you can do the work of ten or fifteen people,” noted the game industry veteran. Brussee strongly suggests the use of AI agents in developing the engine, but whether that means there will be AI tools built into The Immense Engine remains to be seen.

It's true: London-based developer Iakov Sumygin has created a minimalistic playable video game using Gaussian splats for the environment data, and you can load it up and try it right now in your browser. There's not much to do, but we're a tech site, not a dedicated gaming site, and so, as you could imagine, the more interesting part of this story is the technology behind it rather than the extremely basic FPS gameplay.

To understand this post, you're going to have to understand what Gaussian splats are. If you're familiar with the concept of volume pixels, or "voxels," Gaussian splats can be thought of as "voxels of variable size and density." They're not really like voxels; they don't exist in a fixed grid, and they aren't physicalized the same way voxels are. In essence, Gaussian splats are a data type that you can use for representing a 3D world with extremely high visual fidelity, legitimately photo-realistic quality, yet with a modest rendering cost.

Splat scenes, sometimes called "3DGS" scenes, are created quite simply by taking many photos or even videos of a real space and then performing a process called "Structure-from-Motion," which essentially interprets the video data as a 3D scene and creates the sparse point cloud. Then, scene optimization is performed (often using AI) to adjust each Gaussian's position, shape, opacity, and color to match the input images or video.

Gaussian splats are a fairly new technology; while the core idea dates back to Lee Westover's work in the early 1990s, the modern version mostly stems from a paper published by French researchers in 2023 that refined the concept. Since then, the tech has been developed and used quite a bit; last year's Superman movie famously used Gaussian splats for complex visual effects, while musician A$AP Rocky has released music videos with the technique, including one ("HELICOPTER") based on a newer "4D Gaussian Splatting" method that bakes a temporal element into the capture, allowing for moving objects.

Now, you'll notice I said "visual" fidelity above, and therein lies the rub: Gaussian splats can't really be used for interactive media because they don't capture anything about the world except how it looks. Or can they? That's the real innovation of Sumygin's work: taking a pre-made scan of an abandoned building and running it through specialized tools (which he created) to voxelize the splats and create a collision mesh. Boom: workable 3D geometry for a video game.

After that, he baked a lighting grid to apply lighting to the object and character models he imported to the project, vibe-coded a basic AI and pathfinding method for the enemy soldiers, and dropped the whole thing on PlayCanvas, which is a browser-based game engine platform owned by Snap, the company that Sumygin works for. (Yes, that's the SnapChat guys.)

Speaking as a gamer, the demo isn't particularly interesting as a video game. There's one clumsy-looking gun, one enemy model with very static animations, many bugs (my gun was eating more ammo per shot every time I reloaded it), and it's very easy to break, such as by falling through the world. I'm also not as taken with the visuals as some people seem to be. While it does indeed look convincingly photorealistic at points, fine detail is basically nil; in parts, it reminds me of Id Software's Rage, which had gorgeous graphics until you looked too closely at things. Frankly, Unreal Engine 5 projects like Unrecord and Bodycam do the same thing better.

It's really what Sumygin's little game represents that is interesting, because Sumygin's project is completely fascinating from a technical perspective. He doesn't say how long it took him to make, but now that the tooling is done, it should be relatively straightforward and quick for anyone to 3D scan an environment and create a game with impressive visuals based in that environment. It's quite fascinating as a concept. Oh, and the whole project is under 100 megabytes, which is also quite impressive for the level of detail.

If you're a developer interested in the technique, Sumygin's project is completely open-source over on PlayCanvas, including the assets that he used. Frankly, the project is mostly an advertisement for his company's SuperSplat product, but it's an effective one, and it gives a tantalizing glimpse into what could be a very handy tool in the game developers' toolbox.

Yes, you did read the headline correctly, and you'd be wise to fetch a cross, garlic, and a stake. Lyra Rebane, a madlady who dabbles in CSS and infosec, figured out she could leverage the power of contemporary implementations of the stylesheet language to emulate an x86 processor, all without even a single line of JavaScript, WASM, or any other such tomfoolery.

The emulator even comes complete with a basic display and keypad, and some preinstalled programs for calculating the Fibonacci sequence, Pascal's triangle, and a variation of Wordle. You'll need a recent version of a Chromium-based browser, as some CSS features she used are not yet standard. Rebane even goes as far as showing fellow mad-people how to compile their own C programs for the emulator using the gcc-ia16 compiler.

As the first question out of everyone's mouths will be "Can it run Doom?", the answer is that no, it cannot, or at least not yet. While the x86css emulator implements most of the x86 assembly, it's missing key functionality like interrupt handling, port input/output, and block-operation instructions, all key to making most any game as we know them. Perhaps more poignantly, Doom is a 32-bit program and requires a 32-bit CPU (80386 or above), 4 MB of RAM, and the ability to enter protected mode.

Cold-hearted developers like myself will also find some warmth in the fact that Rebane did not use any vibe-coding or AI bot assistance for writing this emulator. And as she points out, a bot could have hardly done this, as the necessary leaps in logic to force CSS to be a full-fledged state machine require some serious out-of-the-box thinking. Rebane points to Jane Ori's CSS CPU Hack as instrumental to her own ideas.

As to the reason or utility of such an enterprise, she simply stated that it was a fun project. Many developers (me included) have long made jokes when people mention HTML and CSS as "programming languages," and this is definitely a moment of harsh acceptance. Some commenters wonder if this implies that contemporary CSS might become a serious attack vector, but that seems unlikely given that Rebane had to create the machine to run the code with.

Developer Daivuk has released QUOD, a 64KB ‘boomer shooter’ with an uncanny resemblance to id Software’s seminal FPS title, Quake. Astonishingly, this tiny executable delivers a Quake-like 3D gaming experience with “3 levels, 1 boss fight, 4 unique enemies, 4 weapons, and a handful of power-ups.” Moreover, it doesn’t call on any external resources; the whole caboodle of textures, sounds, music, levels, models, animations, and code is compressed into that minimal 64KB download.

Above, you can see Daivuk present his own tiny FPS masterwork, in a nicely structured step-by-step video, which touches on topics such as optimizing the textures, maps, models & animations, audio, code, and even creating a virtual machine for a further 2KB of file size savings.

The developer starts by explaining that the QUOD project has been about 10 years in gestation, but has only really been worked upon in the last year. Daivuk indicates to viewers that he has long thought 64KB is the sweet spot for such impressive demos. “It’s very small, but still leaves room for creativity,” he says.

Devotion to optimization shows in several key segments of the video explaining how this 64KB feat was achieved. For example, instead of saving image file resources into the tiny file, Daivuk saved ‘action-based textures’ which are a Photoshop-action-like ‘recipes’ for creating these visual ingredients. The dev even went as far as developing a custom VM and programming language for the sake of smaller file sizes.

Despite its 1980s-era (tape drive, pre-floppy drive) game file size, QUOD.exe still requires a 2010s era CPU and GPU to render its frantic FPS-blasting fun. The minimum specs for this demoscene title include an “Intel i5 or equivalent, GTX 770 or equivalent, 8GB RAM.” Of course, you will also need a spare sliver of disk space – that’s also a mere 64KB, as this is a self-contained non-install application.

Daivuk seems to have plenty of ideas on how to make 64KB demos and games even better. In the video outro, he mentions a host of possible optimizations and refinements that may come to QUOD v2, or whatever may be next. We will be staying tuned to this creator’s channel, for sure.

We’ve seen and reported on impressive small-file-size demo works before, like a colorful ray tracing animation app squashed into a minuscule 483 bytes! We also wrote about a Quake-like JavaScript game in 13KB. Nevertheless, QUOD remains outstanding for its slick Quake(y) FPS playability, looks, and feel. You don’t have to rely on watching the video to judge this, you can download and run it in seconds…

30 years prior

Incidentally, id Software’s Qtest multiplayer-only demo of Quake was released exactly 30 years ago today. But Quake’s shareware release was on June 22, 1996 (MS-DOS), with the full version becoming available to buyers a month later.

The mid-90s was arguably the period in PC history with the most whiplash-inducing changes. The arrival of 3D acceleration cards, the transition from plain-textbox DOS to fancy Windows 95, and the advent of the Internet all happened at once. This rapidly shifting landscape posed quite the challenge for game developers, as they had to consider writing their games for DOS, Windows 95, or both.

In an exceedingly detailed writeup, Fabien Sanglard explains how the OG Quake got its support for TCP/IP and was arguably the only game that used the same executable with native support for both operating systems.

Many games of the era, like Fallout, Grand Theft Auto, and Mortal Kombat 3, would ship separate executables for DOS and Windows 95. However, id Software wanted Quake to use nearly the same executable (and codebase), and it wanted the game to have support for TCP/IP, the Internet communications protocol. Playing remotely with more than one person was the fresh new thing back then; true multiplayer was often limited to home or office networks.

Fulfilling both requirements at once was no easy feat for Quake. DOS was long in the tooth by the time of the game's development and needed a ton of hacks to use all of the hardware capabilities of the time, namely but not only more than 640 KB of memory.

To get around DOS' limitations, games started including DPMI (DOS Protected Mode Interface) extenders like Watcom's DOS/4GW or CWSDPMI. These extenders offered a standardized memory interface, multitasking, and other capabilities. The extender technically served as a micro-kernel, so think of it as a DOS replacement. Typically, games would ship with a target DPMI server and be their single client.

During Quake's development, id wanted to shift from the (at-the-time) proprietary Watcom compiler used in Doom to the open-source djgpp toolkit in a bid to make cross-platform development far easier. Heck, Quake even had a DEC Alpha port, if anyone remembers those. In a shift from the usual arrangement, id asked djgpp's engineers to ensure that its DPMI client supported Windows 95's included DPMI server in addition to CWSDPMI.

The problem was that although DPMI was a standard, its specification was not finalized until the late 90s. That meant that in practice, client software was normally beholden to one specific server. But the djgpp team delivered, and senior Microsoft kernel engineer Raymond Chen put it plainly:

"The fact that programs seem to run mostly okay in spite of running under a foreign extender is either completely astonishing or totally obvious, depending on your point of view."

Quake had native TCP/IP support coded in, yes, but since it was cross-platform, it needed a way to interact with Windows 95's Winsock TCP/IP layer. Additionally, in-game match/server browsers were a new concept at the time, so id killed two grunts with one rocket by enlisting the help of Mpath Interactive and integrating its Mplayer match-making software into Quake.

Mplayer's software comprised two pieces: a "Gizmo" game browser that would autodetect any Mplayer-compatible games you had installed and list game rooms for them, and a solution called the "Chunnel", the component that would actually talk to Windows' TCP/IP stack.

To round out cross-compatibility, Quake also shipped with Mpath's genvxd.dll. This is a virtual device driver that translated DOS networking functionality (that itself uses the now-standard BSD socket function calls) to Windows 95's Winsock. Once that was fitted in, the journey was finally complete, and Quake would run seamlessly in both DOS or Windows, without needing separate installers or executables.

For the nitty-gritty technical details, be sure to visit Fabien Sanglard's deep dive. If this conversation got you raring to play the original game again, go ahead and get the remastered version.

This week in 1988, Cornell graduate student Robert Tappan Morris unleashed his eponymous worm upon the Internet. The wave of infections grew to 10% of the entire Internet within 24 hours, causing astronomically expensive damage for the time. However, the pioneering Morris worm malware wasn’t made with malice, says an FBI retrospective on the “programming error.” It was designed to gauge the size of the Internet, resulting in a classic case of unintended consequences.

Morris worm dissection

Known to be something of a prankster, Morris must have felt some foreboding about releasing his ‘innocent’ program into the wild. Evidence of this comes from his release method. “He released it by hacking into an MIT computer from his Cornell terminal in Ithaca, New York,” according to the FBI.

The Morris worm was written in C and targeted BSD UNIX systems, like VAX and Sun-3 machines. Specifically, the FBI writes, it “exploited a backdoor in the Internet’s electronic mail system and a bug in the ‘finger’ program that identified network users.” In contrast to computer viruses, the worm Morris had devised had no need of a host program, but could self-replicate and spread autonomously.

Thankfully, the Morris worm wasn’t written to cause damage to files. Due to those unintended consequences, though, it precipitated massive slowdowns, and messaging delays and system crashes were common symptoms. It became a computer news sensation in the worst possible way. Just to get rid of the worm in a timely fashion, some institutions ended up wiping complete systems and unplugging networks for as long as a week.

Among the Morris worm's casualties were prestigious institutions such as Berkeley, Harvard, Princeton, Stanford, Johns Hopkins, NASA, and the Lawrence Livermore National Laboratory.

Whodunit?

Experts worked hard to find a fix, and while they did so, the question of who was behind the worm came to the fore. Understandably, whoever created and unleashed this worm needed to feel some consequences, and thus, the FBI was brought in.

Apparently, Morris sought to anonymously explain and apologize for the worm, but an inadvertent slip of his initials by a friend landed Morris in it.

FBI interviews and computer file analysis would subsequently confirm Morris was the culprit. He was indicted under the rather freshly inked Computer Fraud and Abuse Act of 1986. After a court appearance for his misdemeanors in 1989, Morris ended up not with jail time, but with a fine, probation, and 400 hours of community service to complete.

Computer worms have been around longer than the World Wide Web

Back in November 1988, the Internet bore little resemblance to what it is today. For example, the World Wide Web (WWW) wasn’t even a thing. Though the WWW would soon form the core experience for the first tide of surfers in the 90s.

At the time, the Internet’s backbone was the NSFNET, the recent successor to ARPANET. Its purpose was mostly to expand the prior backbone’s reach beyond military and defense institutions, and it more broadly embraced academia. While we are here, it is worth mentioning that NSFNET was decommissioned in 1995, and succeeded by the commercial Internet, which emerged in the 1990s off the back of private ISPs and commercial backbones.

So, when we talk about 10% of the Internet being paralyzed by the Morris Worm, contemporary estimates are that about 6,000 of the approximately 60,000 connected systems were infected and impacted. Moreover, when we highlighted the potentially massive costs of this first worm propagating, estimates range from $100,000 to millions of dollars.

Computer worms have remained a scary phenomenon in recent times. For example, we reported on the first-generation AI worm, the Morris II generative AI worm, last year.

Apple announced at Hexacon 2025, the top global offensive security conference, that it will double its highest security bounty to $2 million. This makes Cupertino the most generous company that offers an award for unearthing vulnerabilities, and it’s even offering top-up bonuses that can see security experts earning more than $5 million for uncovering exploits. According to Apple’s Security Research blog, it has already awarded over $35 million to more than 800 security researchers since 2020, bringing the average award to $43,750. It even claimed that multiple individuals have received $500,000 in rewards.

The top $2-million award is reserved for those who discover sophisticated exploit chains similar to what mercenary spyware attacks exploit. Beyond that, there’s also a bonus system for those who can break Apple’s Lockdown Mode secure environment and vulnerabilities in its beta software, bringing the potential payout to over $5 million. There are also smaller awards, like $1 million for those who can crack broad iCloud security and those who can create a wireless proximity attack using radio, up to $300,000 to anyone who develops a one-click WebKit sandbox escape mechanism, and $100,000 to those who can bypass Gatekeeper on macOS.

This isn’t the only bug bounty program anyone can participate in. AMD announced its own program last year, with a payout of up to $30,000, while Intel offers a maximum of $100,000. Microsoft’s maximum award at the moment is $250,000, and it has even lowered its age limit to 13 because of this high school junior who filed over 20 security vulnerability reports last summer. Meta launched a bug bounty program in 2011 and now offers a maximum bug bounty of $300,000 (with $25,000,000 awarded to date). And last, but not least, Google began its Vulnerability Reward Program (VRP) in 2010. The search giant’s rewards vary from a few hundred dollars to a million dollars for the most serious vulnerabilities on its Titan M security chip. The company paid $11.8 million in 2024 to 660 researchers, bringing the average award to $17,800 per head.

These awards can make finding bugs a lucrative field, especially for talented security researchers. And while it might seem like an expensive proposition for companies, it’s far cheaper for them to pay out these bounties instead of having a bad actor discover it and disseminate it under their noses, resulting in reputational and financial damages for the corporation. Moreover, software mistakes can potentially cost lives, as state actors and other third parties are increasingly using sophisticated means to target specific personalities.

Inkbox Software has released a recreation of a beloved isometric arcade game that runs directly from a PC’s Unified Extensible Firmware Interface (UEFI). Moreover, they coded their version of Zaxxon (1982) in x86-64 Assembly language, and have generously released it as open source under the GPLv3 license. There have been prior UEFI games and apps, but they are often incomplete or limited demos, and run within the UEFI as payloads, rather than booting directly to the game.

In the above video, Inkbox explains the reason they decided to begin this classic arcade gaming UEFI coding quest. In brief, our assembly coding hero says that they were “so tired of operating systems holding me back,” and that they wanted their hardware to run a classic game as it was meant to be played. That means “Written in assembly, without an operating system,” asserts Inkbox. “This is total freedom from big tech. Reject OS, Return to metal.”

Of course, there are significant hurdles to creating a handsome and responsive Zaxxon port for a PC UEFI. You can learn how Inkbox navigated this difficult path in their extensive and in-depth, yet engrossing video.

The Beginner’s All-Purpose Symbolic Instruction Code, BASIC, is where I started my coding journey. Sat, aged four or five in front of a Commodore 16, I typed in lines of words and numbers which made up an application or sound effect. Sometimes they worked, often they did not. The words that I typed, along with “syntax error,” meant nothing to a five-year-old child who wanted sugar-coated cereal and Transformers cartoons, but I persevered.

Fast forward to the 21st century, and I still use BASIC from time to time. I write BASIC on a Commodore 64 and a ZX Spectrum that I recently renovated. I’ve even written BASIC on a Raspberry Pi Pico to control a series of NeoPixels.

Recently, Microsoft open-sourced its MOS,6502 BASIC from 1978, and that got me thinking about writing BASIC on a PC. Sure, I remember QBasic and the gorillas.bas game. I loved tweaking that game on my 486 DX33 back in the 1990s, but I wanted to write BASIC on my Windows 10 PC in 2025.

I can’t use MOS6502 BASIC without spending a lot of time getting it to work on my PC, so what can I use instead? It turns out that there is, and it is called QB64 Phoenix Edition, and it looks and feels just like QBasic, but with many more features.

• Realtime input error checking
• Online and offline help system
• Syntax highlighting
• Automatic source formatting
• Debugging
• Compiles native binaries for Windows, macOS and Linux

QB64 Phoenix Edition (QB64 PE) is a fresh offshoot of the original QB64 project, which seemed to die out in the early 2020s. The project’s goal is to keep the spirit of the old application alive and to provide more people with access to running BASIC on their computers. QB64 PE is cross-platform and it has compatibility with QBasic and QuickBasic 4.5 code. But QB64 PE also gives us an extended BASIC and OpenGL, meaning that we can create applications/games with graphics and sound.

So let's take a look at QB64 PE and create our own BASIC project.

Getting Started with QB64 PE

It really couldn’t be any simpler to get started with QB64 PE.

1. Go to the QB4 PE project page and download the package for your operating system.

2. Extract the file to a directory.

3. Navigate to that directory and double left click on the qb64pe.exe application.

The QB64 PE user interface is very much like QBasic. We have the menu at the top, the coding area in the middle, and a status/output/debugging area at the bottom. Our project will see us working with the File and Run menu.

On first boot, QB64 PE will tell us that the application and any executables made by it can be falsely identified by your anti-virus package. You can optionally whitelist the directory, but I have not had any issues in my testing.

QB64 PE is an awesome application, and I urge you to dig into the gloriously in-depth documentation (which is where I found how to show images) and learn more about QB64 PE.

A short history of BASIC

The BASIC language has been with us since 1964, and it was developed as a high-level (easy-to-read) language by John G Kemeny, chairman of the Dartmouth College Math Department. The name BASIC came from Thomas Kurtz.

The structure of BASIC is meant to be over-simplified on purpose. Each line of BASIC is read by the compiler and turned into bytecode, which the machine can then run. But BASIC can be compiled or interpreted, depending on the version you are using. For example, on the Commodore 64, we see Commodore 64 BASIC V2, a version of Microsoft BASIC, which has a limited number of keywords.

The Project Goal: To Make A Simple Game

Learning BASIC, or any coding language, really, is best done by creating a project. I could sit here and teach you about core programming concepts, or we could have some fun and make a simple game. The game in question is inspired by Usborne’s 1980s BASIC coding books, specifically Computer Space Games, which I adored as a child.

The game is “Escape from planet LXF329,” and the goal of the game is to take off and escape a group of aliens who are trying to capture the spaceship. Essentially, this is a number-guessing game, but with a sci-fi theme.

• Learn the BASIC syntax
• Learn how to display images
• Use conditional statements
• Create variables for integers and strings
• Get user input

You may have spotted “Learn how to display images,” and yes, I will show you how to display a static image on the screen using QB64 PE. In the interest of full disclosure, the images used in the game were generated using Adobe Firefly, an AI service. Why? I could’ve used stock images or spent some time in GIMP and Inkscape, but I didn’t have the time, nor the talent, so Adobe Firefly did the work for me.

We’ll start by creating the starting screen, an image that advertises the game and sets the scene.

1. Create a new blank document and click on File >> Save and save the project as space.bas. Remember to save often.

2. Create a new screen object, setting the screen to 1024 x 1024 pixels and 32-bit color, then set the window title to ESCAPE FROM PLANET LXF329”.

Screen _NewImage(1024, 1024, 32)_Title "ESCAPE FROM PLANET LXF329"

3. Create a variable, myImage& and store your image.

myImage& = _LoadImage("title.png")

4. Create an error handler to check that the image has been loaded correctly. This is basically a conditional check that checks for the loaded file in the variable. If there is nothing there, 0, then it will print an error message.

If myImage& = 0 Then    Print "Error loading image!"    EndEnd If

5. Put the image onto the screen at position 0,0 (top left) then pause the code, waiting for the user to press a key.

_PutImage (0, 0), myImage&Sleep

6. Save the code, and click on Run >> run Only (no EXE) to start the code. Click OK in the dialog to start. You should see the image appear on the screen. Press any key to close the window.

7. Create a label, START: Labels enable us to write code that can jump around to different sections by using a Go To command. You may be familiar with using numbers and jumping to a numbered line. Here ,we are not using numbers, so labels will do the same job.

START:

8. To begin the game code, clear the screen (CLS) and then use a series of print statements to print a narrative to get the reader up to speed on the game mechanics and story.

ClsPrint "ESCAPE FROM PLANET LXF329"Print "Your vessel, the USS TOMSHARDWARE has landed on LXF329"Print "on a routine survey mission"PrintPrint "But the evil aliens, led by HOAL are after your blood!"PrintPrint "Calculate the thrust necessary to take-off and escape"Print "the planet's gravity!"PrintPrint "You only have ten seconds until the aliens burst into"Print "the starship and lay waste to your crew!"

9. Ensure that the game uses pseudo-random numbers. If we don’t do this then the game will pick the same numbers each time.

Randomize Timer

10. Create two variables, g (gravity) and w (weight), which are random integers, multiplied by 20 and 40, respectively. BASIC uses LET to create variables.

Let g = Int(Rnd * 20)Let w = Int(Rnd * 40)

11. Create a third variable to store the correct thrust to leave the planet.

Let r = g * w

12. For debug purposes, print the answer to the screen. Later, comment this out using the REM (remark) keyword.

Print r

Change to this for the final game

REM Print r

13. Print the planet’s gravity and then ask the user to make their thrust calculation.

Print "Planet Gravity = "; gPrint "Type in thrust to escape: "

14. Using a for loop, we give the player ten guesses before the aliens enter the ship.

For c = 1 To 10

15. Stored the player’s guess in a variable, f. That value is compared to the answer, r. If the thrust is too high or low, the for loop repeats until the player runs out of guesses. If the guess is correct, then the game goes to the ENDGAME label.

For c = 1 To 10    Input f    If f > r Then Print "Thrust too high";    If f < r Then Print "Thrust too low";    If f = r Then GoTo ENDGAMENext c

16. Print “the bad ending” to the screen. This section runs if the player fails to make the correct calculations, and then the for loop ends, throwing the user into this nightmare scenario.

PrintPrint "The aliens have entered the starship and you and your"Print "crew are now their prisoners!"Print

17. Add a graphic to show your ship losing against the alien onslaught. You will need to create a PNG file, stored in the same directory as the game file. This is the same code as used for the start screen. Sleeping for 5 is important; otherwise, there is a bug where the screen automatically closes and ends the game.

Screen _NewImage(1024, 1024, 32)_Title "YOU DIED!"myImage& = _LoadImage("die.png")If myImage& = 0 Then    Print "Error loading image!"    EndEnd If_PutImage (0, 0), myImage&Sleep 5

18. Using a GoTo, send the player to the REPLAY section of code.

GoTo REPLAY

19. Print a message to the user to say that they have won. Then show an image on the screen. The ENDGAME label is where the successful player is sent. They are rewarded with a message and an escape image showing them blasting off into space!

Print "You have successfully taken off!"Print "The aliens burn in the wake of your engines"Screen _NewImage(1024, 1024, 32)_Title "YOU WON!"myImage& = _LoadImage("escape.png")If myImage& = 0 Then    Print "Error loading image!"    EndEnd If_PutImage (0, 0), myImage&Sleep 5

20. Create a means to ask the player if they would like to try again. The player’s input is stored as a variable, a. But note that the variable contains a string ($) which can be y or n. If it is y, the game goes back to the START label. Otherwise, the game stops. We use the REPLAY label to identify what the code is for and to direct the player through the game.

REPLAY:Print "Would you like to try again? Press y or n"Input a$If a$ = "y" Then    GoTo STARTElse    StopEnd If

21. Save the code, and click on Run >> run Only (no EXE) to start the code. Click OK in the dialog to start.

22. Run the game a few times, win and lose. Remember that the answer is printed to the screen, so make sure to comment that out when letting your friends have a go.

Complete Code Listing

Screen _NewImage(1024, 1024, 32)_Title "ESCAPE FROM PLANET LXF329"myImage& = _LoadImage("title.png")If myImage& = 0 Then    Print "Error loading image!"    EndEnd If_PutImage (0, 0), myImage&SleepSTART:ClsPrint "ESCAPE FROM PLANET LXF329"Print "Your vessel, the USS TOMSHARDWARE has landed on LXF329"Print "on a routine survey mission"PrintPrint "But the evil aliens, led by HOAL are after your blood!"PrintPrint "Calculate the thrust necessary to take-off and escape"Print "the planet's gravity!"PrintPrint "You only have ten seconds until the aliens burst into"Print "the starship and lay waste to your crew!"Randomize TimerLet g = Int(Rnd * 20)Let w = Int(Rnd * 40)Let r = g * wPrint rPrint "Planet Gravity = "; gPrint "Type in thrust to escape: "For c = 1 To 10    Input f    If f > r Then Print "Thrust too high";    If f < r Then Print "Thrust too low";    If f = r Then GoTo ENDGAMENext cPrintPrint "The aliens have entered the starship and you and your"Print "crew are now their prisoners!"PrintScreen _NewImage(1024, 1024, 32)_Title "YOU WON!"myImage& = _LoadImage("die.png")If myImage& = 0 Then    Print "Error loading image!"    EndEnd If_PutImage (0, 0), myImage&Sleep 5GoTo REPLAYENDGAME:Print "You have successfully taken off!"Print "The aliens burn in the wake of your engines"Screen _NewImage(1024, 1024, 32)_Title "YOU WON!"myImage& = _LoadImage("escape.png")If myImage& = 0 Then    Print "Error loading image!"    EndEnd If_PutImage (0, 0), myImage&Sleep 5REPLAY:Print "Would you like to try again? Press y or n"Input a$If a$ = "y" Then    GoTo STARTElse    StopEnd If

Sharing your work!

If you want to share the game with your friends, then you can! Just bear in mind that the resulting executable is bound to the OS it was created with. Additionally, as QB64 PE notes, your executable may be flagged as a false positive by your antivirus.

1. Click on Run >> Make EXE Only. You can also click on Run >> Start to compile and run the code. This way you get both the executable, and the code will run in the editor.

2. Click OK to compile the executable into the qb64pe folder, the same folder where QB64 PE is being run.

3. Wait for the code to compile. Check the status bar at the bottom of the screen to monitor the progress. On modern systems this will take seconds.

4. Navigate to the folder with the compiled game code. I scanned my compiled code using Microsoft Defender and Malwarebytes, and nothing nasty was found.

5. Double click on the executable to run the game.

A computer scientist used only “pure SQL” to construct a multiplayer DOOM-like game. The resulting first-person shooter game, cobbled from a mere ~150 lines of Python code, is dubbed DOOMQL. Despite the self-imposed software architecture restrictions, Lukas Vogel, co-founder of database performance outfit CedarDB, says DOOMQL plays at “a breezy ~30 FPS.” It isn’t the most graphically splendid DOOM-inspired game, though.

Vogel’s SQL-powered DOOM dreams were precipitated by Patrick Trainer’s DuckDB-DOOM. This earlier experiment in code also sought to create a DOOM-like first-person shooter in SQL. However, Trainer's code, which runs in a single web page in a browser using WebAssembly, also uses JavaScript for rendering and inputs.

Other key differences in DOOMQL and the DuckDB-DOOM clone are that the former is a multiplayer effort, with SQL used for both rendering and input, achieving ~30 FPS at 128 x 64 pixels resolution. Vogel says, without a hint of scorn regarding Trainer’s efforts, that “having parts of the rendering pipeline in JavaScript felt like cheating.” Despite the ‘cheating,’ the DuckDB-DOOM clone only runs at around 8 FPS, and it uses a lower resolution. Making Vogel’s feat all the more impressive is the claim that he coded DOOMQL during a single month while on parental leave.

You can deep dive into Vogel’s SQL-powered DOOM via the linked blog post, and check out the code on GitHub. For a brief overview of the game architecture, though, it can be surmised at the high-level by the following quartet of bullet-points:

• State lives in tables (map, players, mobs, inputs, configs, sprites, …)
• Rendering is a stack of SQL views that implement raycasting and sprite projection.
• The game loop is a tiny shell script that executes a SQL file ~ 30 times per second.
• The client is ~ 150 lines of Python: It polls for input and queries the database for your 3D view.

When it comes to making GUI (Graphical User Interface) applications with Python, we are truly spoilt for choice. We have Tkinter, PyGame, GUIZero, and my personal favourite, EasyGUI.

EasyGUI is old; I was using it to teach Python back in 2015! But, as the name suggests, it's easy to use, and that is why I am still using it over a decade later. It just works across multiple operating systems, and I don’t need to get bogged down in the details of specifying the size and position of a dialog. I just tell EasyGUI that I want a specific type of dialog, and it creates it using the title, message, and interface that I specify. You may be heading to the comments to tell me that PyGame, GUIZero, or some other GUI toolkit is better. If so, please do share your knowledge. We learn by sharing, and I would love to hear your preference.

I also like it because it has a lot of different dialog options, many of which are common across the many applications that we take for granted!

I’ve taken a few screenshots to illustrate.

To see all of the options, we first need to install EasyGUI. For this how to you will need Python installed on your computer. We’ve got a guide for Windows machines, but Linux users should already have it installed.

1. Open a Command Prompt / Terminal. Windows users can find this via the Start menu.

2. Use pip to install EasyGUI. Pip is Python’s built-in package manager.

pip.exe install easygui

3. Start the Python interpreter.

python -i

4. Import the EasyGUI module. I shortened the name of EasyGUI to eg when I imported the module. It makes it easier to use.

import easygui as eg

5. Call the demo function to see all of the different dialog options. Close the dialog window to end the demo.

eg.egdemo()

To create a dialog, first specify the type of dialog, then pass the parameters. Take, for example, this simple button box which has a title, msg, and choice. The title refers to the dialog’s title, the msg is the message to the user, and the choices are a Python list of options, which become buttons. Clicking on a choice will print the choice to the Python shell, or we can save it to a variable for later use.

The Project: A To-Do list in Python

Our goal is simple: create a to-do app that will keep us on track. The app will be written in Python, and use a GUI to make it easier for the end user. The to-do list will be saved to an external file using JSON. Python can easily work with JSON, thanks to the JSON module.

So what are we going to do?

• Download and install the EasyGUI Python module.
• Write Python code in a text editor.
• Import the EasyGUI Python module, along with modules to write the tasks to a file using JSON format.
• Create functions to handle viewing, creating and deleting tasks.
• Test that the app works.

I’m going to assume that you have Python and the EasyGUI module installed, so let's open a text editor and start writing code. I’ll be using Notepad++ on my Windows 10 PC.

1. Open a text editor and create a new blank file. Save the file as to-do.py and remember to save often. I’m using Notepad++, but any text editor will do the job.

2. Import the easygui module and then the modules for using JSON and working with the underlying OS. Remember to rename EasyGUI as you import it for an easier means of calling the module.

import easygui as egimport jsonimport os

3. Create a variable called “filename” to store the name of the JSON file that contains the to-do list. This can be a file anywhere on your system, but in this case it is a file in the same directory as the to-do.py file.

filename = "todo_list.json"

4. Create a function to load the to-do tasks saved in the JSON file. If the file exists (os.path.exists), then the function will return the contents. If there is no file, then it will return a blank list ( [ ] ).

def load_tasks():    if os.path.exists(filename):        with open(filename, "r") as f:            return json.load(f)    else:        return []

5. Create a function to save the to-do tasks into the JSON file. We open the file and overwrite the existing contents with the new list, which is formatted into a JSON structure.

def save_tasks(tasks):    with open(filename, "w") as f:        json.dump(tasks, f)

6. Call the load_tasks function and store the output (what the Python function returns) into a variable called tasks. The load_tasks function will either return the existing to-dos stored in the JSON file, or create a blank Python list.

tasks = load_tasks()

7. Create a while True loop to run the code until the user exits.

while True:

8. Using EasyGUI, create a variable called “choice” and in there we store the user’s response to a button box. The first line is the text that is displayed to the user, note the \n which is Python for new line. The second line is the title of the dialog box. Image can be any GIF image that you choose. Finally, the choices are stored in a Python list, and they become clickable buttons that return the chosen value, stored in the variable “choice.”

  choice = eg.buttonbox(        msg="What would you like to do?\nSelect an option below",        title="To-Do List",        image="clipboard.gif",        choices=["View Tasks", "Add Task", "Remove Task", "Exit"]    )

9. Create a conditional test, based on the user’s response to the button box. If their choice was to view the current tasks and there are tasks in the JSON file, display them using an EasyGUI textbox. Else, tell the user that there are no tasks to display, again using a textbox.

    if choice == "View Tasks":        if tasks:            eg.textbox("Your Tasks:", "To-Do List", "\n".join(tasks))        else:            eg.msgbox("No tasks yet!", "To-Do List")

10. Create the second choice in the conditional test which activates if the user selects “Add Task” from the button box. This creates a variable, task, that stores the user’s input via an EasyGUI enterbox. Then it appends the tasks object (a list) and calls the save_tasks functions to write the list into the JSON file. Finally, a message box confirms that the tasks have been added.

   elif choice == "Add Task":        task = eg.enterbox("Enter a new task:", "Add Task")        if task:            tasks.append(task)            save_tasks(tasks)            eg.msgbox("Task added!", "To-Do List")

11. Create the next choice, which activates when a user selects to “Remove Task”. If there are tasks to remove, an EasyGUI choicebox will advise the user to select a task for removal. Then a nested if condition will remove the task from the task list (a Python list of the tasks), and then tell the user that the task has been removed. If there are no tasks to remove, then an EasyGUI message box will tell the user.

   elif choice == "Add Task":        task = eg.enterbox("Enter a new task:", "Add Task")        if task:            tasks.append(task)            save_tasks(tasks)            eg.msgbox("Task added!", "To-Do List")

12. Using an else condition, create a break in the code to exit the app. This is effectively our quit / exit button.

   else:        break

13. Save the code.

14. Open a Command Prompt window and navigate to the location of the to-do app.

15. Run the to-do app using Python and test out the functions of the app. You’ve just built a graphical application using EasyGUI and Python.

python to-do.py

If you want to make a true GUI application, one that has its own icon and doesn’t need the Command Prompt to run, then follow this guide and use your to-do.py file instead of the example code.

Complete Code Listing

import easygui as egimport jsonimport osfilename = "todo_list.json"def load_tasks():    if os.path.exists(filename):        with open(filename, "r") as f:            return json.load(f)    else:        return []def save_tasks(tasks):    with open(filename, "w") as f:        json.dump(tasks, f)tasks = load_tasks()while True:    choice = eg.buttonbox(        msg="What would you like to do?\nSelect an option below",        title="To-Do List",        image="clipboard.gif",        choices=["View Tasks", "Add Task", "Remove Task", "Exit"]    )    if choice == "View Tasks":        if tasks:            print(tasks)            eg.textbox("Your Tasks:", "To-Do List", "\n".join(tasks))        else:            eg.msgbox("No tasks yet!", "To-Do List")    elif choice == "Add Task":        task = eg.enterbox("Enter a new task:", "Add Task")        if task:            tasks.append(task)            save_tasks(tasks)            eg.msgbox("Task added!", "To-Do List")    elif choice == "Remove Task":        if tasks:            task_to_remove = eg.choicebox(                "Select a task to remove:",                "Remove Task",                tasks            )            if task_to_remove:                tasks.remove(task_to_remove)                save_tasks(tasks)                eg.msgbox("Task removed!", "To-Do List")        else:            eg.msgbox("No tasks to remove!", "To-Do List")    else:        break

A total of 18 JavaScript packages that have over 2 billion weekly downloads have been injected with malicious code in what is billed as the largest supply chain hack in history. The compromised code was designed to steal cryptocurrency.

Picture this: Thanos, a Death-obsessed maniac retconned within the Marvel Cinematic Universe to be the most radical environmental activist in history, has assembled the Infinity Gauntlet. With it, he could wipe out half the universe's population. He raises his hand, snaps his fingers, and... steals a bunch of cryptocurrency instead. The Infinity Gauntlet would still be a problem, sure, but wouldn't that first snap come as a relief?

That's kind of how the recent compromise of JavaScript packages that have been downloaded billions of times feels. Does the ease with which an unknown threat actor was able to compromise the maintainer of these packages, modify the software, and distribute it highlight the disastrous state of modern software development? Absolutely. But we're lucky—they prioritized getting rich over wreaking havoc.

Here's what happened. Aikido said yesterday that 18 packages "were updated to contain a piece of code that would be executed on the client of a website, which silently intercepts crypto and web3 activity in the browser, manipulates wallet interactions, and rewrites payment destinations so that funds and approvals are redirected to attacker-controlled accounts without any obvious signs to the user."

The packages in question are distributed via npm, GitHub's package manager and registry for the Node.js ecosystem, and they are collectively downloaded approximately 2 billion times per week. In theory, the hacker could have used the ability to modify these packages to do anything; Aikido said they opted to attempt to steal "Ethereum, Bitcoin, Solana, Tron, Litecoin, and Bitcoin Cash."

We don't know how far these malicious packages spread. The packages themselves are downloaded billions of times a week, but that's at least partly a byproduct of software build systems constantly fetching and re-fetching a project's dependencies. There's no denying these packages are popular, though, and organizations whose software depends on them should make sure they aren't using the malicious releases.

But was this at least the result of a sophisticated attack? No. The maintainer of these packages (who, it should be noted, uses the handle "bad-at-computer" on Bluesky) said they received a two-factor authentication reset email that "looked very legitimate" from "support@npmjs.help" and thought it was benign. It wasn't. All it took to pull off a hack of this scale was a domain name, an email, and the willingness to try.

This isn't a new problem, nor is it exclusive to npm. I reported in 2021 that hackers were targeting maintainers of packages used by JavaScript, Python, Ruby, and Java developers in their own software, and even then, the problem had been known for years. The infamous left-pad incident—wherein the deletion of 11 lines of code "broke the internet" because so much software depended on it—happened in 2016.

The industry has been attempting to address this problem by encouraging the use of software bills of materials (SBOMs), requiring maintainers of widely used packages to secure their accounts with two-factor authentication, etc. Yet this incident proves that these measures are not enough. Until the commonly accepted processes of developing, maintaining, and releasing software change, these problems will persist.

This time, the Infinity Gauntlet was used to steal cryptocurrency. Will the next Thanos snap their fingers with the same intention? And which is going to come first, the snap that causes far more damage than a crypto thief, or the arrival of something that can finally stop that snapping altogether? Thanos claimed that he's inevitable; are we really just consigning ourselves to hoping that was only true on the silver screen?

An engineer has tapped into Apple’s LidAngleSensor MacBook API to create an app which displays the angle read from the sensor on the screen. Though a cool and worthy tool in its own right, Sam Gold’s app is elevated to a higher plane as it also includes an audio feedback option to “play a wooden door creaking sound if you adjust it reeaaaaaal slowly.” A video demonstration is embedded below,

Product designer and engineer, Gold, explained to their X followers that the LidAngleSensor API isn’t exposed to the public, but he still managed to figure out how to read it. A more technical explanation of the API, what devices use it, as well as downloads of the code and a ready-compiled app can be found on Github.

Since the LidAngleSensor.app was announced at the weekend, Gold has fielded many queries and requests via social media. A pretty common question was why he had created this app. The answer seems to be that Gold currently has a lot of free time, but is eager to start something more meaningful and full-time “in NYC or remote.” So, perhaps this quirky project could precipitate a great job for this imaginative fellow.

Gold also tried to address various MacBook model incompatibilities, but he doesn’t have access to every modern Apple laptop. The creaky door sound source was revealed in a FAQ to be poached from LEGO Batman 3: Beyond Gotham.

Theremin mode delivered

There have been lots of fun suggestions for adapting the LidAngleSensor.app for new sounds and purposes. These range from the practical, like a protractor mode for a wood shop, to the hilarious, like a Pac-Man controller “where you have to open and close the laptop to move,” suggested by Gold.

However, Gold was emboldened and inspired enough by his own brainwave idea of creating a theremin mode to actually implement this elegant and ghostly electronic instrument in the app.

Edit 9/5/2025 9 am ET: A representative from NYU's Tandon School of Engineering contacted Tom's Hardware to claim responsibility for the malware referenced in the below article — this malware, found by ESET, was in fact a research project from the school. We have issued a follow-up article covering the situation, which you can read here: AI-powered PromptLocker ransomware is just an NYU research project — the code worked as a typical ransomware, selecting targets, exfiltrating selected data, and encrypting volumes

Original article follows:

ESET today announced the discovery of "the first known AI-powered ransomware." The ransomware in question has been dubbed PromptLock, presumably because seemingly everything related to generative AI has to be prefixed with "prompt."

ESET said that this malware uses an open-weight large language model developed by OpenAI to generate scripts that can perform a variety of functions on Windows, macOS, and Linux systems while confounding defensive tools by exhibiting slightly different behavior each time.

"PromptLock leverages Lua scripts generated from hard-coded prompts to enumerate the local filesystem, inspect target files, exfiltrate selected data, and perform encryption," ESET said in a Mastodon post about the malware. "Based on the detected user files, the malware may exfiltrate data, encrypt it, or potentially destroy it. Although the destruction functionality appears to be not yet implemented."

Lua might seem like an odd choice of programming language for ransomware; it's mostly known for being used to develop games within Roblox or plugins for the NeoVim text editor. But it's actually a general-purpose language that offers a variety of advantages to the ransomware operators—including good performance, cross-platform support, and a focus on simplicity that makes it well-suited to "vibe coding."

It's important to remember that LLMs are non-deterministic; their output will change even if you provide the same input with the same prompt to the same model on the same device. That's maddening if you expect them to exhibit the exact same behavior over time, but ransomware operators don't necessarily want that, because it makes it easier for defensive tooling to associate patterns of behavior with known malware.

PromptLock "uses the gpt-oss:20b model from OpenAI locally via the Ollama API to generate malicious Lua scripts on the fly," which helps it to evade detection. The fact that the model runs locally also makes it so OpenAI can't snitch on the ransomware operators—if they had to call an API on its servers every time they generate one of these scripts, the jig would be up. The pitfalls of vibe coding don't really apply, either, since the scripts are running on someone else's system.

Maybe this will make for a decent consolation prize for AI companies. Yeah, they're facing massive lawsuits. Sure, basically nobody has seen any benefits from adopting their services. Okay, so even Meta's cutting back on its AI-related spending spree. But nobody can say that AI is useless—it's convinced at least some ransomware operators to use local models in their warez! That counts for something, right?

GitHub has become one with Microsoft today, marking the end of the website's independence. Former CEO Thomas Dohmke announced he would step down from his role at GitHub today, leaving Microsoft to take control of the company. GitHub will now become part of Microsoft's CoreAI team, with no successor yet announced for Dohmke.

Dohmke shared in a GitHub blog post that his departure is due to a desire to found a new tech startup. Dohmke will stay on at GitHub through the end of the year to assist in the transition of folding GitHub fully into Microsoft, leaving his founder dreams on hold until then. In his personal X (formerly Twitter) post announcing his resignation, Dohmke teased that future projects may include a new GitHub successor.

GitHub is one of the largest code repositories in the world, having become an essential tool for spreading and collaborating on code projects. It was built based on Git, a distributed version control system for developers created by Linus Torvalds in 2005 to support the development of the Linux kernel. GitHub recently saw its one billionth repo hit the site, which was simply the word "sh*t".

Dohmke has been a key part of GitHub in the Microsoft era, joining the company following Microsoft's $7.5 billion acquisition of the site in 2018 and becoming CEO in 2021. GitHub reached 150 million users and 1 billion repos under Dohmke and became the first landing place for Copilot AI. Microsoft's original acquisition of GitHub allowed the site to continue operating independently from Microsoft. However, that independence will soon end as GitHub, a currently remote-first workplace, becomes further wrapped into Microsoft's control.

Microsoft's decision to wrap GitHub into its CoreAI teams likely indicates an intent to double down on GitHub's AI projects. GitHub Copilot, the first iteration of Copilot to make it to commercial launch in the Windows ecosystem, has become a successful AI coding assistant and a key part of GitHub's public focus, recently receiving a free version for all users. The focus on AI-assisted coding is a well-debated topic in the programming world, with even AI coding assistants hallucinating and telling users to stop using it and learn to code themselves.

Some internet speculators have become wary of the future of GitHub now that it is becoming fully wrapped into Microsoft. Past acquisitions, such as those of Skype and Xamarin, serve as examples of companies and programs that Microsoft has since discontinued. Some fear GitHub may face a similar fate if it is not rebranded and Teams-ified instead. The future of GitHub is uncertain, but Microsoft is highly unlikely to discontinue the operations of the cornerstone of modern coding.

The activation method for a rather ancient Easter egg, hidden deep within the ROMs of beige Apple Power Mac G3 computers, has been uncovered. Self-confessed "combined Apple/Linux/Windows geek" Doug Brown published a blog on Tuesday, discussing how he rediscovered the 'hidden dev team' Easter egg on a lazy Sunday. There was no known documented way of displaying this Easter egg in the Finder (Apple desktop). However, thanks to deeper detective work, some programming knowledge, and the help of friends, Brown eventually found and shared the method of activating this significant Easter egg. It is pretty easy, when you know how.

The PowerMac G3 computers were the mainstay of Apple computer-reliant businesses in the late 90s – until everything went pastel translucent with the introduction of the iMac line. As a reprographics worker at the time, I owned a couple of beige G3 machines for home use, and remember them fondly, moving up from Mac OS 7.5.3 through to 9.x. I also remember lots of software having fun Easter eggs that could be activated. That was quite high-octane Mac computing fun at the time, and this would be at least five years ahead of YouTube being a thing, for example. The Easter eggs I remember most clearly were conjured up by holding various modifier keys while selecting various menu items.

Brown found that the existence of the image was already known and documented from previous ROM hacking adventures. However, no one knew how a casual Mac user might see the image pop up as a ‘surprise’ on their system.

Intrigued and warming to the potential challenge, Brown looked more closely at text strings in similar locations to the image (a JPG). Working using various tools, including Ghidra, a software reverse engineering (SRE) framework, he eventually narrowed down the RAM disk driver as the prime suspect.

After Ghidra decompiled the code, it was determined that a process associated with the RAM disk would check for a string that was equal to ‘secret ROM image’ before it would create and write a file named ‘The Team.’ This was enough information to start to try and hunt the Easter egg in the ‘real world’ of the classic Mac OS, or so Brown thought...

Help came from fellow InfoSec Exchange user Alex, who managed to trigger the Easter egg as follows: “with hints from (Downtown) Doug Brown, we just discovered the trigger for the beige PowerMac G3's secret ROM image: go to the Memory control panel, set up a RAM disk, reboot to mount it, go Special → Erase Disk and name the volume secret ROM image — you'll get a file The Team at its root, type JPEG, creator ttxt. enjoy!”

This file will open in the Mac’s basic built-in editor, SimpleText, which is just advanced enough to be able to render JPG images. Just double-click 'The Team' file, and you will see the 26-strong team in the photo, reproduced top.

Enjoy this Easter egg via the magic of emulation

A high-tech tinkerer has managed to get Apple’s iOS to run on the Nintendo Switch. Don’t get too excited, though, as PatRyk on X wryly admits they have created “the world’s slowest ‘iPhone’.” Booting this Nintendo ‘iPhone’ currently takes 20 minutes, and all the apps they tried crash – but it’s a start.

Baby steps

While the gaming tech world is all a flutter with the recently launched Switch 2, PatRyk spent two days attempting to shoehorn Apple’s mobile OS onto the best-selling hybrid console. This enthusiast’s modesty seems to be matched by their patience, as the new Nintendo ‘iPhone’ takes 20 minutes to boot. We wonder how many times they waited that length of time, or even longer, for the boot process to hang or otherwise fail?

Using the mobile OS also sounds like an incredible life-sapping chore, with this ‘iPhone’ in its current state. PatRyk says that the system “kernel panics every 2nd thing you do, can’t open any apps (they all time out and crash).”

At this stage, the project might sound dire, but it shows that running iOS on the original Switch is possible – it just needs optimization. But you aren’t going to be ditching your real Apple iPhone for a Switch any time soon.

Underlying technology - the versatile QEMU

Software engineer Sven Scharmentke (AKA Svnscha) has shared a project that they say "might change crash dump analysis forever." The new contextual natural language conversational tool contrasts sharply with manually typing arcane commands into a terminal to analyze crash data, which is the established modus operandi of a professional software engineer, even in 2025. Svnscha goes on to assert that the new open-source tool, available as mcp-windbg on GitHub, can go deep. The AI runs a "simply amazing" array of WinDBG/CDB commands, boosting productivity and eradicating a once tedious task.

AI peddlers have developed large language models that initially targeted creative writing and have since moved to visual arts – graduating from hand-drawn style art and photorealistic creations to videos in recent times. AI has also made significant inroads into computer programming. However, most people want AI to leave the fun, creative stuff to humans and take the sting out of dull, soul-crushing, repetitive tasks. This seems to be where Svnscha's mcp-windbg might actually succeed.

In brief, the mcp-windbg tool enables AIs to interact with Microsoft's multipurpose debugger WinDBG. Its cunning skill is in giving LLMs the ability to execute debugger commands. And, even if you have swallowed the WinDBG manual, this AI will likely know debugger commands better than you. Copilot will probably also interpret assembly code, decode hexadecimal, traverse structures with symbols, and perform other tasks much better than you. You just have to ask the right questions.

Background and demos

Svnscha goes into some detail about their prior frustration in debugging crashes, the lightbulb moment to involve AI, and how the mcp-windbg tool works, all in a dedicated blog post. The software engineer humbly admits the 'hard part" of this work was implementing the CDB (Microsoft's Command-Line Console Debugger) interaction layer, and this was done during a session "vibe-coding with two coffees on a Saturday morning."

However, the videos shared help encapsulate the leveraging of Copilot with CDB. There are two to watch on the linked blog, starting with a Crash Analysis and Automated Bugfix using Copilot, followed by an Automated Crash Dump Analysis of Multiple Crash Dump Files.

What you first see shows Svnscha installing mcp-windbg, then running a Windows app that crashes. Next, GitHub Copilot is fired up and asked to find the crash dump and fix the underlying code issue. "The AI quickly identifies that the application crashed, explains which specific conditions led to the crash, and suggests a fix," says Svnscha.

The second video is similar but shows the tool analyzing multiple files simultaneously.

'Simple wrapper' lifts crash analysis from the stone age to the rocket age

The OneChipBook-12 from 8086YES! might look like a chunky netbook from years ago, but it is actually an FPGA development platform centered around the Cyclone EP1C12Q core. For those unfamiliar, an FPGA, or field-programmable gate array, is a type of integrated circuit that can be reprogrammed after manufacturing. This flexibility means it can be configured thousands of times into a wide variety of digital circuits, making it an excellent learning tool for experimenting with hardware design.

The Altera Cyclone EP1C12Q240 chip on the OneChipBook-12 offers over 12,000 logic elements and 240kbits of RAM. It’s paired with 32MB of SDRAM and an SD card slot for storage (FAT16 supported), giving it just enough power and flexibility for retro computing projects or educational experimentation.

The unique aspect of the OneChipBook-12 is its self-contained design. Unlike most FPGA dev boards that require you to bring your own monitor, keyboard, and power supply, this one has everything built-in. It uses a 1024x768 LCD panel, salvaged from an old iPad 2, and a backlit mechanical PS/2 keyboard available in two layouts — a standard version, with function keys, and a version customized for MSX-style emulation, including KANA and GRAPH keys.

For I/O it includes a PS/2 port, dual DB9 joystick ports, and USB Type-A, while video output options include VGA, S-Video, and composite video. The device also comes with built-in stereo speakers, a 3.5mm headphone jack, and a volume knob that adds to the retro appeal. A small expansion cartridge slot and DIP switch round out the customization options, while power comes from a USB Type-C port and an internal lithium battery, making it portable enough to carry around in a backpack.

You can purchase the OneChipBook-12 on Tindie and Ebay for $215 or around $235 on AliExpress. It may not be for everyone, but if you’ve ever wanted a portable FPGA dev kit, this might be worth the money.

The OneChipBook-12 doesn’t ship with a firmware, but it does include a USB Blaster for loading your own FPGA cores. As pointed out by CNX-Software, the provided PDF documentation offers hardware details along with general guidance on flashing firmware. However it lacks any instructions on how to install MSX firmware — likely due to legal concerns.

Some users have pointed out that the device was once marketed as the MSXBook, a name that has since been dropped to avoid infringing on the MSX trademark. The company behind the OneChipBook-12 reportedly offered support in the past, but no longer do so. However, if you are still interested, this webpage offers more detailed guidance on flashing firmware to the device (although it is in Japanese).

Ever wanted to see a Nintendo Entertainment System released in 1986 run the .NET Framework released for Windows platforms in 2000? If you're the same kind of techno-degenerate who enjoyed .NET being backported to Windows 95, you're most likely in the right place, though of course the NES isn't going to be nearly as capable as your average Windows 95 PC. 

Before proceeding, let's take a moment to put the processing power of the mighty Nintendo Entertainment System in context — since it was powerful for its day, after all. The NES boasts an 8-bit CPU running at 1.78 MHz — that's right, MHz, not kHz!— and enjoys a generous 2 Kilobytes of RAM and of VRAM allocation. 

It can also handle game cartridges with up to 512 Kilobytes of storage, which our needlessly determined .NET porter (Microsoft's Jon Peppers) noted would barely be enough for modern Android/iOS app icons. The most popular iOS/Android apps also tend to run the gamut from 55-206 MB, which is orders of magnitude higher than anything an NES could ever hope to comprehend.

So, why was this done? A wide assortment of reasons are provided in the original presentation. These include learning how to convert MSIL to 6502 assembly, for API design and .NET development experience, and most importantly a simple "Nerd Flex". Although, for a "Nerd Flex", this one seems fairly limited in its uses compared to the last .NET Framework-related nerd flex that actually fundamentally improves Windows 95. Right now, .NET on NES isn't even playing any games, it's mostly just running Hello World and other simple demos.

But it's still pretty cool, especially considering the fact it works at all. Several components of .NET were cut from this implementation to make it work on the NES' limited hardware, including a lot of compatibility-related code, the debugger, and other optional components of .NET. Or, "optional" if you happen to be running it on an NES, I guess.

In the cruel absurdity of the universe at large, never forget that your old hardware can always be put to use as long as it still functions. Usually, that means something like playing old games, but sometimes it means creating entirely new games and expansions to keep old hardware alive. Other times, it's about fixing or fundamentally replacing old hardware to keep the aesthetics alive without sacrificing too much functionality.

As the author? My personal favorite has still got to be porting N64 games to PC with ray-tracing and uncapped FPS, though that's keeping software alive rather than hardware.

BenQ has announced its new RD Programming Series of monitors. These coder-friendly screens offer standard features like a 16:10 ratio display, Advanced Coding Modes, eye care protection for working at night and "Brightness Intelligence" auto-dimming, anti-glare screen coatings, and ergonomic stands. 

The first in the series is the new RD240Q, a 24.1-inch model with a 2,560 x 1,600 pixels IPS panel.

The new RD Programming Series is the world’s first designed to cater to the specific needs of programmers, reckons BenQ. But before we pick over those special coder-friendly features, we shall look at the basic tech specs of the new RD240Q to see how it stands up on a hardware level.

Based on a 24.1-inch IPS screen, the BenQ RD240Q is pretty small by trending monitor sizes in 2024. However, it offers extra useful verticality by employing 2,560 x 1,600 pixels, and delivers a pixel density of 125ppi. Moreover, at least some of BenQ’s promo materials envision coders using two or three of these displays.

Benq’s RD240Q goes up to 300 nits of brightness, offers a typical 1000:1 contrast, and covers 95% of the DCI-P3 gamut. In terms of performance, we are looking at a max refresh rate of 60 Hz and a response time of 5 ms. These specs are very ordinary. If this was a monitor aimed at casual PC users, only the resolution offered would stand out and we would expect it to be a value-targeted monitor.

So, what has BenQ done to make this a worthwhile choice for programmers? Much of the special coder sauce is in the firmware, offering modes like Coding - Dark Theme, Coding - Light Theme, ePaper, HDR, M-Book, and Cinema. Also, BenQ claims the coding modes offer “crystal clear fonts and improved code differentiation.” We would like to see these claims put to the test in a third-party review.

As part of its MoonHalo experience, BenQ says the RD240Q offers some eye-soothing features that are meant to limit your exposure to blue light and Brightness Intelligence Gen2 auto-dimming of the display to match your environment. A rear LED ring provides adjustable environmental lighting. Flicker-free technology is present too. The anti-glare and anti-reflective features here also sound appealing to for spending a long time concentrating on the screen.

BenQ provides a stand that offers tilt (-5 degrees - 20 degrees), swivel (15 degrees/ 15 degrees), pivot, and height (110 mm) adjustments. If you pivot the display it is smart enough to auto-rotate. If you don’t like or need the stand, the monitor comes with 100 x 100 VESA mounting holes. Display Pilot 2 software is also provided for display adjustments and management.

The port selection seems adequate. Users get one each of HDMI 2.0, DP 1.4, and USB -C (daisy chainable). As well as offering display connectivity the USB-C can provide power and data transfer. BenQ’s RD240Q can provide three USB-A outs and one USB-C out, offering hub functionality. There is a headphone jack and a pair of 2W built-in speakers.

We don’t have BenQ RD240Q pricing and retail availability details at the time of writing. Coming soon to the RD Programming Series will be a pair of larger screen options, specifically the 28-inch 4K+ RD280U/UA, and 31/5-inch 4K+ RD320U/UA.

BASIC, the programming language best known today for having the most "dialects" of derived programming languages, turned 60 this month. The original version of BASIC (Beginner's All-Purpose Symbolic Instruction Code) is also referred to as "Dartmouth BASIC", since its origins are with Dartmouth, a university based in New Hampshire. Naturally, it serves as the foundation point for dozens of later BASIC languages. 

The original, Dartmouth BASIC launched in May 1964 and received updates and maintenance all the way up through 1979. In the times before BASIC and accessible programming languages like it, PCs were still machines that took up entire rooms and had to be programmed on a near case-by-case function to do much of anything. People say that BASIC "democratized" programming, and this is because besides being one of the first major programming languages, and it's actually one of the most accessible, too.

Dartmouth BASIC was developed alongside "a time-sharing system" to be used with a General Electric computer. In this context, time-sharing refers to a PC that is built to divide its resources among multiple terminals at the same time— and the first-ever test of BASIC was done with two BASIC applications simultaneously across two separate terminals connected to the same GE-225 machine.

So, just how influential is Dartmouth BASIC? To this day, several dozens of BASIC dialects tailored to specific use cases and devices have been seen in the past six decades. Early offshoots of BASIC include Atari BASIC, Microsoft BASIC, and even TI-BASIC* alongside Commodore BASIC. *That's Texas Instruments. 

More recently, major dialects include Microsoft's Visual Basic and its offshoots. Coverage of the Dartmouth BASIC 60th anniversary by The Register also highlights closely-timed updates to Small Visual Basic 3.0, SE BASIC 4.2, and a custom QB64 QuickBasic, which is derived from Microsoft's QuickBasic.

Of course, those operating critical machines should be wary when building with or using applications that rely on older versions of BASIC. Did you know the U.S. government recommends against using programming languages like C++ due to them not being considered "memory-safe"? 

Of course, no one's going to stop a regular old hobbyists from programming whatever they like with whatever they like— and no one should. We highly recommend anyone who wants to start getting into BASIC programming or one of its many dialects do so, because it's basically the programming language that taught most newer ones how to be accessible.

All that said, it's worth noting that Dartmouth BASIC isn't the first programming language— that honor actually belongs to either Ada Lovelace's 1843 machine algorithm or Konrad Zuse's 1940 Plankalkul — and plenty of subsequent languages aren't based on it at all.

Lists are a common way to store multiple pieces of data in Python. By creating one list we can neatly store many different types of data within it. They work just like a shopping list. We give the list a name, then enter items under the list. 

Lists are another data storage structure, just like dictionaries, tuples and sets. Lists are mutable objects, we can change the contents by updating, deleting and adding to a list. Objects stored in a list come under the broad term of “items” and each item has a position in the list, an index number. The first object in the list has the index number of zero, and as we get more items, it counts up.

We’re going to learn how to create lists and then update and delete the items within them. Then we will apply our knowledge to create a shopping list app which sends lists directly to our cell phone.

To demonstrate how to use lists in Python, we will use Thonny, a free, easy to use and cross platform Python editor. 

Before you begin, install Thonny if you don’t have it already. Go to the Thonny site to download the release for your system. Alternatively, install the official Python release using this guide. Note that this guide covers installation on Windows 10 and 11.

How To Create a List in Python

The most basic form of a list involves creating the list object and then placing items inside of it.

1. In a new blank document, create a list called “shopping” and in there store three items of shopping. Items in a list can be integers, floats, strings, even another list. Lists can also be created with no items, shopping = [] will create a blank list but we will need to append data to it. We cover updating lists later.

shopping = ["Apples","Bananas","Milk"]

2. Print the entire contents of the list. This shows the list contents, including the [ ] brackets.

print(shopping)

3. Save the code as shopping.py and click Run >> Run Current Script. The output looks something like ['Apples', 'Bananas', 'Milk'] which proves that the list works, but we can use it to generate content in sentences.

4. Add another print function to identify that we are printing a shopping list.

print("The shopping list contains")

5. Using a for loop with a range, we print each item from the list, using Python’s string formatting method to drop the item into the sentence as a string. How do we know the number of items in a list to create a range? Well right now it doesn’t matter as the len() function will calculate the length of the shopping list object and use that value as the range. Then the for loop will iterate through the items, updating the value of i each time the loop iterates.

for i in range(len(shopping)):   print("I need to buy {:s}".format(shopping[i]))

6. Save the code and click Run >> Run Current Script. We will see the full list printed, then our shopping list text is printed to the Python Shell.

Complete Code Listing: Creating a List

shopping = ["Apples","Bananas","Milk"]print(shopping)print("The shopping list contains")for i in range(len(shopping)):   print("I need to buy {:s}".format(shopping[i]))

Updating and Deleting Items in a List

Lists are mutable objects. This means we can create, update and delete entries from a list. In our current shopping list we have bananas, but we have looked in the fruit bowl and found that we have plenty of bananas, but we have no grapes! So lets swap the bananas for grapes.

1. On a new line outside of the previous for loop, print a message to say that we are updating the contents of the shopping list.

print("Shopping list has changed")

2. Change Bananas to Grapes by updating the value for that item in the list. We know that “Bananas” is the second item in the list, as Python counts from zero we know that the item's position in the list is 1.

shopping[1] = "Grapes"

3. Using a for loop with a range we print each item from the list. This will print out the old list, and then the updated list.

4. Save and run the code. The updated list, and the previous list are printed to the Python Shell.

We open the fridge door and realize that we need to add butter, eggs and cheese to our shopping list. We can append a single item to the end of the list or we can extend the list and pass it multiple items.

1. On a new line outside of the previous for loop and print a message to say that we are updating the contents of the shopping list, again.

print("Shopping list has changed again")

2. Append Cheese to the shopping list. Append will add the item to the end of the list.

shopping.append("Cheese")

3. Use extend to add multiple items to the shopping list. Extend requires us to wrap the items that we wish to add in parenthesis. These new items can be any iterable objects, in this case I have used a tuple to contain the items.

shopping.extend(("Butter","Eggs"))

4. Using a for loop with a range we print each item from the list. This will print out the old lists, and then the updated list.

5. Save and run the code. The updated list, and the previous lists are printed to the Python Shell.

We get to the store and realize that we don’t need eggs! So let's take them off our list.

1. On a new line outside of the previous for loop, print a message to say that we are removing the eggs.

print("Removing the eggs")

2. Remove the eggs from the shopping list. Note that the item value is case sensitive. “Eggs” is not the same as “eggs”.

shopping.remove("Eggs")

3. Use a conditional statement to check that Eggs are no longer on the shopping list. If there are eggs, it will tell us that we forgot to remove them. If there are no eggs, then the else condition will activate and print that they have been removed from the list.

if "Eggs" in shopping:   print("I forgot to remove the eggs")else:   print("The eggs have been removed from the list")

4. Save and run the code. If the eggs have been removed you will see a confirmation, if not, then you will see a reminder.

Complete Code Listing: Updating and Deleting Items in a List

print("Shopping list has changed")shopping[1] = "Grapes"for i in range(len(shopping)):    print("I need to buy {:s}".format(shopping[i]))print("Shopping list has changed again")shopping.append("Cheese")shopping.extend(("Butter","Eggs"))for i in range(len(shopping)):    print("I need to buy {:s}".format(shopping[i]))print("Removing the eggs")shopping.remove("Eggs")if "Eggs" in shopping:    print("I forgot to remove the eggs")else:    print("The eggs have been removed from the list")

Using a For Loop With a List

Earlier we used a for loop with a range to print the items in our shopping list using its position (index number). There is another way though, we can create a variable and using a for loop we can iterate over the items in the shopping list and print them out. All of this is accomplished without the need for an index number.

1. On a new line, print a message to say that we are using a for loop.

print("Using a for loop to print our shopping list")

2. Use a for loop to iterate over each item in the shopping list. The value of “item” will change each time the for loop iterates. When all of the items have been iterated through, the for loop will end.

for item in shopping:

3. Print the message to the Python Shell using string formatting. We only need to pass the item variable, not shopping(item) as we are working inside the list.

   print("I need to buy {:s}".format(item))

4. Save and run the code. The for loop will print out the contents of the shopping list.

Complete Code Listing: Using a For Loop With a List

print("Using a for loop to print our shopping list")for item in shopping:   print("I need to buy {:s}".format(item))

Using Lists in a Real World Project

A shopping list on our desktop computer isn’t much use really, but a shopping list on our cell phone, and the cellphones of other family members is. We’re going to use ntfy.sh, a service to send notifications to Android and iOS devices. We used it in our Dictionaries how to as a service to send messages and images to devices.

1. Install ntfy.sh for your Android / iOS device.

2. Open the app and click on + to create a new subscription.

3. Create a new topic and click Subscribe. We chose to use th-shopping-list. Create a topic that is personal to you. Also note that topics may not be password protected, so do not send sensitive data.

4. Leave the app open on your device. 

Now our attention turns to our PC running Thonny.

5. Create a blank file.

6. Import the requests module. This is a module of pre-written Python code designed for sending and receiving network connections.

import requests

7. Create a blank list called shopping.

shopping = []

8. Create a variable, num_items and using an input function, capture the answer to the question and save it as an integer. The input function can take a prompt argument, with it we can create custom prompts.

num_items = int(input("How many items do you want to add to your shopping list? "))

9. Using a for loop, iterate through the required number of items, asking the user to enter the item name and append to the shopping list. Another input function is used to capture the users shopping items, the prompt has to be a string for we use f-string formatting to convert. What we convert is the value of i, the item. The value of i is linked to the index number, the item’s position in the list. In the list it starts from zero, but for the input prompt we add one to the value for something that is more understandable for most humans. This is purely cosmetic and does not impact the list index numbers.

for i in range(num_items):   item = input(f"Enter item {i+1}: ")   shopping.append(item)

10. Print a message and then use a for loop to print the contents of the shopping list. This is more for debugging, but useful to check that our list is correct.

print("The shopping list is:")for item in shopping:   print(item)

11. Create a new variable, shopping_list and in there store the entire contents of the shopping list, using commas to separate the values. This is a formatting step to ensure that the list is sent correctly via ntfy.sh.

shopping_list = (", ".join(shopping))

12. Send the shopping list to the correct ntfy.sh topic. The shopping_list object is the data that we wish to send, the header is a title to clearly identify what the data is.

requests.post("https://ntfy.sh/th-shopping-list",   data=shopping_list,   headers={ "Title": "Shopping List" })

13. Save the code as shopping-list.py and click Run. Enter the number of shopping list items, press Enter and type each item and press Enter. Once the final entry has been made, the final Enter key press will send the list to your cellphone / mobile device. Check your device for the notification.

Complete Code Listing: Real World Project

import requestsshopping = []num_items = int(input("How many items do you want to add to your shopping list? "))for i in range(num_items):   item = input(f"Enter item {i+1}: ")   shopping.append(item)print("The shopping list is:")for item in shopping:   print(item)shopping_list = (", ".join(shopping))requests.post("https://ntfy.sh/th-shopping-list",   data=shopping_list,   headers={ "Title": "Shopping List" })

More Python Tutorials

• How To Install Python on Windows 10 and 11
• How to use For Loops in Python
• How to Enumerate in Python
• How to Create Executable Applications in Python
• How To Remove Backgrounds From Images With Python
• How to Create Web Apps with Python, HTML and Thonny
• How To Use Raspberry Pi Camera Module 3 with Python Code

Python How Tos

• How To Install Python on Windows 10 and 11
• How to use For Loops in Python
• How to Enumerate in Python
• How to Create Executable Applications in Python
• How To Remove Backgrounds From Images With Python
• How to Create Web Apps with Python, HTML and Thonny
• How To Use Raspberry Pi Camera Module 3 with Python Code

Functions are incredibly powerful. We use them every day of our lives. When our parents said “clean your room!” We knew what had to be done. Functions are blocks of code that are executed when we call their name. But they can do much more than that. Functions can have arguments (parameters) passed to them, so we could pass a function the latest temperature from a sensor and use the function to trigger a fan to turn on. We could use a function to read the contents of a dictionary and work on the data stored within it.

In this how to. we will introduce the concept of functions and a few of its most powerful features. We will also build a project to read the current status of our PC and provide the data to the Python Shell.

To demonstrate how to use functions in Python, we will use Thonny, a free, easy to use and cross platform Python editor. 

Before you start, Install Thonny if you don’t have it already. You can download the release for your system on the app’s official site.

Alternatively, you can install the official Python release using this guide. Note that this guide covers installation on Windows 10 and 11.

How to Create a Function in Python

Functions are “defined” using the “def” keyword. When the function name is called, the contents of the function are run and the output is sent to the Python Shell.

1. Create a function called hello. As is tradition in programming, we will use “Hello World” as a quick and simple demonstration of using a function.

def hello():

2. Add a for loop that will iterate (loop) ten times. For loops are an easy way to repeat actions in any programming language. Here we are using a range to set the number of loops, but for loops can also iterate through objects in lists, dictionaries or tuples.

   for i in range(10):

3. Use print to output “Hello World!” to the Python Shell. Print is a built-in function for Python. Its role is to print objects. The message that we want to print is called an “argument” or “parameter” and we will cover this later in the how to.

   print("Hello World!")

4. Save the code as hello_world.py and click Run >> Run Current Script, or press the green run button. What happens? Here is where we make a mistake to reinforce how functions work. Our function has been created, but we have not called the function, so Python is waiting for a command.

5. On a new line, not inside the for loop or function, call the function by its name. Remember to include the parenthesis at the end of the function name.

hello()

6. Click Run >> Run Current Script, or press the green run button. The Python Shell will see “Hello World!” printed ten times.

Complete Code Listing: A Simple Function

def hello():    for i in range(10):        print("Hello World!")hello()

How to Create a Function With Arguments

Arguments, sometimes called parameters, are extra instructions to an object. Python’s functions can use arguments, we just need to add them into the parentheses. By default, Python will not look for an argument in a function, we need to set a template / expectation for the function. 

In this section we will alter our “Hello World!” function to accept two arguments. The first is for the number of iterations in a for loop, the second will be for the phrase that we wish to repeat. When specifying arguments we need to ensure that we pass the correct number. If the function specifies two arguments, then we need to pass it two. Failure to do this will cause the function call to error.

1. Create a function called hello and pass it two arguments, x and phrase. We use x as a placeholder for the number of loops, “phrase” is used to represent the message that we want to print.

def hello(x, phrase):

2. Add a for loop that will iterate x times. The number of times that the loop will iterate is controlled using the x argument.

   for i in range(x):

3. Use print to output the “phrase” argument to the Python Shell. Remember, the phrase is set when we call the function.

    print(phrase)

4. On a new line, not inside the for loop or function, call the function by its name and pass the two arguments. The number of times to loop (x) and the message to print. We’ve chosen to loop five times and print Tom’s Hardware. It's not original, but it illustrates the goal of the project.

hello(5, "Tom's Hardware")

5. Save the code as hello_world.py and click Run >> Run Current Script, or press the green run button. The phrase will be printed to the Python Shell for the X number of times that you specified as an argument. 

Complete Code Listing: Functions With Arguments 

def hello(x, phrase):    for i in range(x):        print(phrase)hello(5, "Tom's Hardware")

How To Create a Function With Default and Keyword Arguments

We’ve passed arguments to our functions, but we can also set a default argument. The default will be accepted and used if the function is passed without a user set argument. Here is a quick example which has a default argument of name. The default name is my own, and it is used in the function to greet the user. All we need to do is pass the name argument to create a new named greeting.

1. Create a function with a default argument of name. Obviously change the name to your choosing.

def whoareyou(name = "Les"):

2. Using the name argument, print a greeting to the user. Here we use Python’s string format method to insert the name argument as a string.

   print("Hello {:s}!".format(name))

3. Call the function with no argument. This should show that the default name is used.

whoareyou()

4. Call the function and pass a new name as an argument. Calling the function happens outside of the function itself.

whoareyou("Dave")

5. Save the code as name.py and click Run >> Run Current Script, or press the green run button. We can see that the code outputs two greetings. One for the default, the other for “Dave”.

Complete Code Listing: Functions With Default Argument

def whoareyou(name = "Les"):    print("Hello {:s}!".format(name))whoareyou()whoareyou("Dave")

Keyword arguments are useful when we have multiple arguments to pass. In this example we use the classic Mad Libs structure to create a sentence with a noun, verb and thing. The order of the arguments doesn’t matter as we provide the key = value structure.

1. Create a function and configure it to accept three arguments.

def madlibs(noun, verb, thing):

2. Create a sentence that will print the noun, verb and thing to the Python shell. Again we use Python’s excellent string format method to drop the arguments into the sentence.

   print("The {:s} {:s} over the {:s}.".format(noun, verb, thing))

3. Save the code as madlibs.py and click Run >> Run Current Script, or press the green run button.

4. In the Python Shell, call the function and pass the three arguments. Remember to use the key, otherwise the order will be incorrect. Press Enter to run the code. You will see the sentence appear using your custom keywords.

madlibs(noun = "rabbit",verb = "jumped",thing ="gate")

Complete Code Listing: Functions With Multiple Arguments

def madlibs(noun, verb, thing):   print("The {:s} {:s} over the {:s}.".format(noun, verb, thing))

Using Functions to Get PC Performance Data

To illustrate how to use functions we are going to create a quick Python project that will get live CPU and RAM data using the psutil (process and system utilities) Python module.This module can get data on CPUs, RAM, disks, networks and other sensors, all using Python.

Before we can write any code, we need to install the psutil module.

1. In Thonny, click on Tools >> Manage Packages.

2. Search for psutil and click Search on PyPi.

3. Select psutil from the returned results.

4. Install psutil then close the dialog box when it is complete. We have already installed psutil so our dialog looks a little different.

5. Create a new file in Thonny and import the psutil module.

import psutil

6. Create a function, cpu(). This function will get the current CPU utilization and store it in a variable. We then print the value to the Python Shell using a string format.

def cpu():   cpu = str(psutil.cpu_percent())   print("Current CPU usage is {:s}%".format(cpu))

7. Create a new function, ram(). Use a print statement, along with some math to print a title with ten * either side.This function will handle all of the steps necessary to get the current amount of available memory.

def ram():   print("*"*10,"RAM Stats","*"*10)

8. Get the current memory stats and store them in a variable called “memory”.

   memory = psutil.virtual_memory()

9. Extract the current amount of available RAM and store it in the variable. The memory object initially returns the total, available, percent, used and free memory. The returned object is a list, and we need the second value in the list, which is [1].

   memory = memory[1]

10. Convert the amount of memory into Megabytes and round the value for ease of reading.

   memory = round(memory / 1024 / 1024)

11. Print the amount of available memory to the Python Shell.

   print("There is {:n}MB of available RAM".format(memory))

12. Create a function called cores(). This function will return the physical core count and the number of threads our CPU has.

def cores():

13. Create objects to store the physical number of CPU cores, and the number of threads. Setting the logical=False argument will force psutil to only return the physical cores.

   physical = psutil.cpu_count(logical=False)   threads = psutil.cpu_count()

14. Print the physical core count and thread to the Python Shell.

   print("This CPU has {:n} cores and {:n} threads".format(physical, threads))

15. Create a new function, cpuspeed(). Use a print statement, along with some math to print a title with ten * either side.

def cpuspeed():   print("*"*10,"CPU Stats","*"*10)

16. Store the current CPU speed data to an object called speed. Then extract the current speed and update the object. Initially we get a list which contains a tuple with three values, current speed, min, and max speed. So we need to get data from the first entry in the list [0], then get the first entry in the tuple [0].

   speed = (speed[0][0])

17. Print the speed to the Python Shell.

   print("The CPU speed is {:n} MHz".format(speed))

18. Create a function called all() and use it to call all of the previous functions. Functions can call other functions.

def all():   cpuspeed()   cores()   cpu()   ram()

19. Create a try / except handler and use while True: to run our code. This section will try to run our code.

try:   while True:

20. Create an object, stat, and use it to store the user’s choice. We use an input() function to capture keyboard input from the user. We can also create a prompt asking the user for their choice.

       stat = input("Please type 'cpu', 'ram', 'cores', 'cpuspeed' or press ENTER to show all stats: ")

21. Use conditional tests to check the value stored in stat and route the code to the correct option.

       if stat == "cpu":           cpu()       elif stat == "ram":           ram()       elif stat == "cores":           cores()       elif stat == "cpuspeed":           cpuspeed()

22. Use else as a catch all option that will call the all() function and show every stat that we have a function for.

       else:           all()

23. Create an exception to handle the user pressing CTRL+C to end the code. This will print Exiting to the Python Shell.

except KeyboardInterrupt:   print("Exiting")

24. Save the code as performance.py  and click Run >> Run Current Script, or press the green run button. You will see the Python Shell ask for your input. Follow the guidance and your requested data will display in the Shell.

Complete Code Listing: Using Functions to Get PC Performance Data

import psutildef cpu():   cpu = str(psutil.cpu_percent())   print("Current CPU usage is {:s}%".format(cpu))def ram():   print("*"*10,"RAM Stats","*"*10)   memory = psutil.virtual_memory()   memory = memory[1]   memory = round(memory / 1024 / 1024)   print("There is {:n}MB of available RAM".format(memory))def cores():   physical = psutil.cpu_count(logical=False)   threads = psutil.cpu_count()   print("This CPU has {:n} cores and {:n} threads".format(physical, threads))def cpuspeed():   print("*"*10,"CPU Stats","*"*10)   speed = psutil.cpu_freq([1])   speed = (speed[0][0])   print("The CPU speed is {:n} MHz".format(speed))def all():   cpuspeed()   cores()   cpu()   ram()try:   while True:       stat = input("Please type 'cpu', 'ram', 'cores', 'cpuspeed' or press ENTER to show all stats: ")       if stat == "cpu":           cpu()       elif stat == "ram":           ram()       elif stat == "cores":           cores()       elif stat == "cpuspeed":           cpuspeed()       else:           all()except KeyboardInterrupt:   print("Exiting")

More Python Tutorials

• How To Install Python on Windows 10 and 11
• How to use For Loops in Python
• How to Enumerate in Python
• How to Create Executable Applications in Python
• How To Remove Backgrounds From Images With Python
• How to Create Web Apps with Python, HTML and Thonny
• How To Use Raspberry Pi Camera Module 3 with Python Code

Microsoft’s Stefan Kinnestrand announced today that Microsoft Excel will officially support Python integration. This will be accomplished via a partnership with Anaconda which brings a huge repository with common libraries like statsmodels, Matplotlib and pandas. The new Python integration is available starting today as a preview for those in the Beta Channel Microsoft 365 Insiders group.

The integration will become a part of the many tools offered in Excel’s repertoire. As such, you won’t have to take any additional steps to add Python to your copy of Excel. More specifically, this integration will be implemented as a part of Excel’s data transformation tool known as Power Query.

If you want to get in on the early action, you’ll need to be a part of the Beta Channel Insider group in the Microsoft 365 Insider Program. The preview will be automatically included in the latest Insider build. Just install the latest copy of Excel offered and open a new workbook. In the ribbon go to ‘Formulas’ then ‘Insert Python’. There you should have an option to try the preview.

Anaconda has more details about their work on the project over at their official website. We definitely recommend checking it out for an inside look at what the new Python support is capable of. They also offer training courses which can help you get off the ground with the new addition.

The preview will only be available for a limited time so now is your chance to check it out and see what it’s like hands-on. The preview will also be extended to Microsoft 365 subscribers. Once the preview expires, it will still be available but with limited functionality. To restore full access, users will need to purchase a license.

If you want to get a closer look at the details of the new rollout, we recommend both reading through the official announcement shared by Microsoft as well as the official documentation from Anaconda.

In Python, dictionaries are data storage objects that use a key to retrieve a value. Think of your cell phone contact list or phone book. We look for the name of the person, the key, and their phone number is the value. Dictionaries are incredibly useful when storing and sorting data. We used a dictionary in our for loop project which saw RSS news feeds used to generate content on a web page. 

We’re going to go through how to create, update and delete keys and values inside of a dictionary and then use a dictionary in a real world project where we create a notification system using Python and nfty.sh.

To demonstrate how to use Dictionaries in Python, we will use Thonny, a free, easy to use and cross platform Python editor.

1. In a browser go to the Thonny website and download the release for your system.

2. Alternatively, install the official Python release using this guide. Note that this guide covers installation on Windows 10 and 11.

How To Create a Dictionary in Python

The most basic use for a dictionary is to store data, in this example we will create a dictionary called “registry” and in it store the names (keys) and starship registries / numbers (values) of characters from Star Trek.

1. Create a blank dictionary called “registry”. Dictionaries can be created with data already inside, but by creating a blank dictionary we have a “blank canvas” to start from.

registry = {}

2. Add a name and ship number to the registry. Remember that the name is a key, and the ship number is the value. Values can be strings, integers, floats, tuples, and lists.

registry["James T Kirk"] = 1701

3. Add another few names to the registry.

registry["Hikaru Sulu"] = 2000registry["Kathryn Janeway"] = 74656registry["Ben Sisko"] = 74205

4. Print the contents of the registry dictionary.

print(registry)

5. Save the code as starfleet-registry.py and click Run to start the code.

Complete Code Listing: Creating a Dictionary

registry = {}registry["James T Kirk"] = 1701registry["Hikaru Sulu"] = 2000registry["Kathryn Janeway"] = 74656registry["Ben Sisko"] = 74205print(registry)

Updating and Deleting Entries in a Dictionary.

Dictionaries are updatable (mutable in programming parlance) and that means we can update the key (names) and the values (ship numbers).

For our first scenario, we’ve had a call from Ben Sisko, and he wants his entry updated to Benjamin. We’re going to add this code to the previous example code.

1. Add a print statement to show that we are making updates. This is entirely optional, but for the purpose of this example it clarifies that we are updating the dictionary.

print(“UPDATES”)

2. Add a “Benjamin Sisko” key and set it to use the value stored under “Ben Sisko”.

registry["Benjamin Sisko"] = registry["Ben Sisko"]

3. Delete “Ben Sisko” from the registry.

del registry["Ben Sisko"]

4. Print the current contents of the registry. We can see that the “Ben Sisko” key is now gone, and is replaced with “Benjamin Sisko”. The value has also been transferred.

print(registry)

Next we will update the entry for James T Kirk. It seems that he has a new ship number (something to do with “accidentally” setting an easy password on his self-destruct app) and so we need to update the value for his entry.

1. Add a print statement to show that we are making updates. This is entirely optional, but for the purpose of this example it clarifies that we are updating the dictionary.

print("Kirk's new number")

2. Update the “James T Kirk” key with the new ship number. Note that because we are adding -A to the value, we have to wrap the value in “ “ to denote that we are now using a string.

registry["James T Kirk"] = "1701-A"

3. Print the contents of the registry. We can now see that James T Kirk has a new ship number.

Finally we need to delete Benjamin Sisko from the registry. It seems that he has gone “missing” while in the fire caves on Bajor. So we need to delete his entry from the registry. We’ll use the existing code, and add three new lines.

1. Add a print statement to show that we are deleting entries. This is entirely optional, but for the purpose of this example it clarifies that we are deleting entries from the dictionary.

print("Deleting Benjamin Sisko")

2. Delete “Benjamin Sisko” from the registry. We don’t know who the new captain will be yet.

del registry["Benjamin Sisko"]

3. Print the registry to confirm the deletion.

print(registry)

4. Save and run the code.

Complete Code Listing: Updating and Deleting a Dictionary

registry = {}registry["James T Kirk"] = 1701registry["Hikaru Sulu"] = 2000registry["Kathryn Janeway"] = 74656registry["Ben Sisko"] = 74205print(registry)print("UPDATES")registry["Benjamin Sisko"] = registry["Ben Sisko"]del registry["Ben Sisko"]print(registry)print("Kirk's new ship")registry["James T Kirk"] = "1701-A"print(registry)print("Deleting Benjamin Sisko")del registry["Benjamin Sisko"]print(registry)

Using a For Loop With Dictionaries

For loops are awesome. We can use them to iterate through an object, retrieving data as it goes. Lets use one with our existing code example to iterate through the names (keys) and print the name and ship number for each captain.

1. Create a for loop to iterate through the keys and values in the registry dictionary. This loop will iterate through all the items in the dictionary, saving the current key and value each time the loop iterates.

for keys, values in registry.items():

2. Create a sentence that embeds the Captain’s name (keys) and the ship’s number / registry (values).

print("Captain", keys, "registry is", values)

3. Save the code and click Run. You will see the name and ship number for each captain printed at the bottom of the Python shell.

Complete Code Listing: Using a For Loop With Dictionaries

registry = {}registry["James T Kirk"] = 1701registry["Hikaru Sulu"] = 2000registry["Kathryn Janeway"] = 74656registry["Ben Sisko"] = 74205print(registry)print("UPDATES")registry["Benjamin Sisko"] = registry["Ben Sisko"]del registry["Ben Sisko"]print(registry)print("Kirk's new ship")registry["James T Kirk"] = "1701-A"print(registry)print("Deleting Benjamin Sisko")del registry["Benjamin Sisko"]print(registry)for keys, values in registry.items():   print("Captain", keys, "registry is", values)

Using Dictionaries in a Real World Project

We’ve learnt the basics, now lets use a dictionary in a real world project. We’re going to use ntfy.sh, a service to send notifications to Android and iOS devices. The Python API for ntfy.sh is based on dictionaries. Best of all, there are no Python installation files as it uses Python’s requests module to handle sending messages to ntfy.sh.

1. Install ntfy.sh for your Android / iOS device.

2. Open the app and click on + to create a new subscription.

3. Create a new topic and click Subscribe. We chose to use th-test. Create a topic that is personal to you. Also note that topics may not be password protected, so do not send sensitive data.

4. Leave the app open on your device. 

Now our attention turns to our PC running Thonny.

5. Create a blank file.

6. Import the requests module. This is a module of pre-written Python code designed for sending and receiving network connections.

import requests

7. Use requests to post a message to ntfy. Note that we need to specify the topic name, in our case https://ntfy.sh/th-test, as part of the function’s argument. The next argument, data is the text that the user will see. But our interest is in “headers” as this is a dictionary which can contain multiple entries. Right now it contains a title for the notification.

requests.post("https://ntfy.sh/th-test",   data="This is a test of ntfy for Tom's Hardware",   headers={ "Title": "Python Dictionaries are useful" })

8. Save the code as dictionary-ntfy.py and click Run. This will send the message to ntfy’s servers and from there the notification will appear on your device.

Complete Code Listing: Real World Project

import requestsrequests.post("https://ntfy.sh/th-test",   data="This is a test of ntfy for Tom's Hardware",   headers={ "Title": "Python Dictionaries are useful" })

An Advanced Real World Dictionary Project

Lets create a more advanced project, one that uses a dictionary to store multiple items. We’re going to reuse the code from before, but tweak it to meet our needs.

1. Our import and requests line remain the same.

import requestsrequests.post("https://ntfy.sh/th-test",

2. Open and read a file into memory. This is the data that is sent in the notification. In this case we start with an image that is in the same directory as our code. If the image is in a different location on your machine, specify the full path to the file.

   data=open("yoga.jpg", 'rb'),

3. Create a dictionary called “headers”. This forms the information that is sent in the notification.

   headers={

4. Inside the headers dictionary, specify the following keys and values.

Priority 5 messages are urgent, the highest priority and they will set your phone to vibrate / ring continuously until they are answered.

Tags: These are emojis and tags used to add icons and extra data to a notification. If the tag has an emoji, then you will see it.

Title: The top title, in bold for the notification.

Click: When you click on the notification, it will open the web page.

Filename: The name of the file that is being sent.

       "Priority": "5",       "Tags": "rotating_light",       "Title": "Let me in, it is cold!!",       "Click": "https://www.tomshardware.com/reviews/elecfreaks-cm4-xgo",       "Filename": "yoga.jpg"   })

5. Save the code and click Run. Now look at your device and you will see a notification showing our custom message.

Complete Code Listing: Advanced Project

import requestsrequests.post("https://ntfy.sh/th-test",   data=open("yoga.jpg", 'rb'),   headers={       "Priority": "5",       "Tags": "rotating_light",       "Title": "Let me in, it is cold!!",       "Click": "https://www.tomshardware.com/reviews/elecfreaks-cm4-xgo",       "Filename": "yoga.jpg"   })

More Python Tutorials

• How To Install Python on Windows 10 and 11
• How to use For Loops in Python
• How to Enumerate in Python
• How to Create Executable Applications in Python
• How To Remove Backgrounds From Images With Python
• How to Create Web Apps with Python, HTML and Thonny
• How To Use Raspberry Pi Camera Module 3 with Python Code

Once you’ve created a list or collection in Python, it might be useful to have each item numbered. Instead of going through the list manually and adding numerals one by one, it can be well worth looking into the enumerate function. This is a built-in tool that will go through a list and automatically number them in the order they were added to the tuple or list.

In this guide, we’ll go over how to use this enumerate function with an existing list. We’ll assume you already have familiarity with how to create a variable, list, and use functions. Once the list has been enumerated, it can be called later with the enumeration in place. You can even use a for loop (see how to use for loops in Python) to iterate through the enumeration.

What is Enumeration in Python?

Enumeration is the ordered listing of all items in a collection. In Python we can use this with a list or tuple to (data collection objects) into an enumerate object. The enumerate object has a name and value for each enum member within the object. The enumerate object can be updated (mutable) unlike other objects such as tuples which are immutable (cannot be updated).

How to Enumerate in Python

To demonstrate how to use enumeration in Python, we’ll start with a list of flavors and label it ‘flavors’. After applying the enumeration function, we’ll print the list which will show that each item has been marked with a numeral sequentially.

1. Create a list, collection or tuple. In this case we have three flavors in a list labeled as a variable named ‘flavors’.

flavors = ('Raspberry', 'Vanilla', 'Chocolate')

2. Run the enumerate function. In the example code below, we’ve created a variable named ‘choices’ that consists of the enumerate function parsing the ’flavors' object, as an argument.

flavors = ('Raspberry', 'Vanilla', 'Chocolate')choices = enumerate(flavors)

3. Print the list. You can now call the 'flavors' object as needed in your code. For the sake of our example, we’ll print the list to show what it looks like when the list has been enumerated.

flavors = ('Raspberry', 'Vanilla', 'Chocolate')choices = enumerate(flavors)print(list(choices))

4. Confirm the results. The printed list should appear as follows if the enumeration was successful.

[(0, 'Raspberry'), (1, 'Vanilla'), (2, 'Chocolate')]

Even though we’ve printed the list to show the enumerate function, this is just to demonstrate how it works. You can apply it in your code as needed after the second step but printing the list is a quick way to make sure it’s working as intended.

We earlier mentioned that enumerated collections have a value and name associated to the data stored within. We can individually extract these values. Here is a quick example that creates an enumerated collection of foods.

1. Import the enum module. 

import enum

2. Create a new enumeration object using a function-call syntax. Our object is called food, and in there we store a list of foods. By using the enum.Enum function call we bind  values to each of the item names.

food = enum.Enum('food', ['Tomato', 'Cucumber', 'Chocolate'])

3. Use a for loop to print the value and name of each item in the object. The for loop will iterate over every item in the object. We then print the value and name of the item.

for item in food:    print(item.value, item.name)

4. Run the code. The output will be the enumerated value of the item's position and the name of the item.

1 Tomato2 Cucumber3 Chocolate

Using Enumeration to Number Chapters in a Book

There are plenty of practical applications for applying numbers to a list. In this example, we'll number the chapters in a book we're pretending to write. This example also shows how you can start a list from any number so it doesn't begin with the default value of 0.

I'll be using Thonny for this example. It's a free Python editor that works on several platforms. You can find it available for download on the official Thonny website. However, you can use any editor you like for your project.

1. Make your list. In this case, my list is a handful of fake chapters for our book.

chapters = ["How to Enumerate in Python", "Creating a List", "Enumerating the List"]

2. Set the beginning of the list to 1 instead of 0. The next line tells Python that we want the chapter enumeration to begin at 1. The words 'chapter' and 'title' can be anything you like.

chapters = ["How to Enumerate in Python", "Creating a List", "Enumerating the List"]for chapter, title in enumerate (chapters,1):

3. Print the list. The third line prints the chapter variable which has the title argument setting the list to begin at 1.

chapters = ["How to Enumerate in Python", "Creating a List", "Enumerating the List"]for chapter, title in enumerate (chapters,1):print(chapter, title)

4. Run the program. It should print the chapters with the enumeration beginning at 1.

Python How Tos

• How To Install Python on Windows 10 and 11
• How to use For Loops in Python
• How to Enumerate in Python
• How to Create Executable Applications in Python
• How To Remove Backgrounds From Images With Python
• How to Create Web Apps with Python, HTML and Thonny
• How To Use Raspberry Pi Camera Module 3 with Python Code

In programming, for loops are incredibly versatile tools to repeat a section of code. For loops can loop for a set number of times using a range, they can have clauses / conditions which will end the loop and we can use them to iterate over items in a dictionary, list or tuple.

In this how to, we will show you how to get started with for loops using Python, the same syntax will also work with MicroPython and CircuitPython on boards such as the Raspberry Pi Pico.

To demonstrate how to use for loops in Python, we will use Thonny, a free, easy to use and cross platform Python editor. 

1. In a browser go to the Thonny website and download the release for your system.

2. Alternatively, install the official Python release using this guide. Note that this guide covers installation on Windows 10 and 11.

Using a Range with Python For Loops

The most basic for loop use in Python is to iterate over a range, essentially creating a loop that will only iterate for a set number of times. While “range” is not strictly part of the syntax for a for loop, it is really a built-in Python function that returns a sequence for a specific pattern, it is the easiest way to demonstrate how a for loop works.

1. Create a for loop and set the range to 10.This will set the value of x to an integer value, starting at 0 and ending at 9. The loop will iterate until it reaches the tenth loop, then it will end.

for i in range(10):

2. Print the current value of i as part of a sentence. Here we use Python’s string format method to insert the loop number each time the loop iterates.

   print("This is loop: {:n}".format(i))

3. Save the code as for_loop_range.py and click Run to start. You should see this output.

This is loop: 0This is loop: 1This is loop: 2This is loop: 3This is loop: 4This is loop: 5This is loop: 6This is loop: 7This is loop: 8This is loop: 9

Complete Code Listing: For Loop With a Range

for i in range(10):    print("This is loop: {:d}".format(i))

Using a For Loop With RSS Feeds

To better illustrate how we can use a for loop, let's use a for loop with a range to pull the top five headlines from BBC News’ RSS feed along with their corresponding URL.

1. Install feedparser using pip at a command prompt. Feedparser is an RSS parsing tool that we shall use to read the RSS feed and convert it into a Python dictionary.

pip install feedparser

2. In Thonny, create a new blank Python file and import feedparser.

import feedparser

3. Create an object, newsfeed, and in there store the parsed BBC News feed.

newsfeed = feedparser.parse("http://feeds.bbci.co.uk/news/rss.xml")

4. Use a for loop with a range of five.

for i in range(5):

5. Print the headlines (title) and the URL (link) of the top five stories. Here we are accessing the newsfeed object, which is a dictionary (array) that contains many more dictionaries and lists. Using the keys (entries, title and link) we can get the values that they store. The value of [i] increments, until it reaches 5, then the loop ends. We have how tos covering dictionaries and lists which go into further detail.

   print(newsfeed['entries'][i]['title'])   print(newsfeed['entries'][i]['link'])

6. Save the code as news_for_loop.py and click Run. You should see the top five news headlines.

Complete Code Listing: Using a For Loop With RSS Feeds  

import feedparsernewsfeed = feedparser.parse("http://feeds.bbci.co.uk/news/rss.xml")for i in range(5):    print(newsfeed['entries'][i]['title'])    print(newsfeed['entries'][i]['link'])

For Loops With an Early Exit

Ranges can also feature an “early exit”. This uses a conditional statement that checks the value of the of the loop (in our case it is stored in i) and if it matches the value, the code breaks and exits.

We’re going to reuse the code from the first example to start us off.

1. Add a conditional test that checks the value of i is the same as 4. In Python == is an operator that checks that one value is the same as another.

   if i == 4:

2. Print a sentence to inform the user that the loop is terminating. This part of the code will only activate once “i” contains the value 4.

       print("This loop sequence terminates at loop {:n}".format(i))

3. Break the loop, forcing the code to stop.

       break

4. Save and run the code. You should see this output.

This is loop: 0This is loop: 1This is loop: 2This is loop: 3This is loop: 4This loop sequence terminates at loop 4

Complete Code Listing: For Loop With an Early Exit

for i in range(10):    print("This is loop: {:n}".format(i))    if i == 4:        print("This loop sequence terminates at loop {:n}".format(i))        break

Nested For Loops

We can have multiple for loops running together. For example we can nest one for loop inside of another. In this example we are reusing the code from the first example.

for i in range(10):   print("This is loop: {:n}".format(i))

1. Add a nested for loop that will iterate ten times. Ensure that the variable name is different to the main loop, otherwise the two will clash.

   for j in range(10):

2. Add a print statement to inform the user that this is the nested for loop.

       print("This is nested loop: {:n}".format(i))

3. Use a break to exit out of the nested for loop. If we don’t do this, then the nested for loop will repeat each time the main loop iterates.

       break

4. Save and run the code. You should see this output.

This is loop: 0This is nested loop: 0This is loop: 1This is nested loop: 1This is loop: 2This is nested loop: 2This is loop: 3This is nested loop: 3This is loop: 4This is nested loop: 4This is loop: 5This is nested loop: 5This is loop: 6This is nested loop: 6This is loop: 7This is nested loop: 7This is loop: 8This is nested loop: 8This is loop: 9This is nested loop: 9

Complete Code Listing: Nested For Loops

for i in range(10):   print("This is loop: {:n}".format(i))   for j in range(10):       print("This is nested loop: {:n}".format(i))       break

Iterating With For Loops

Iterating over objects in a list, dictionary or tuple is useful if we want to use data from these objects. In this example, we will reuse the code from our RSS feed reader to create a simple web app. A ranged for loop will grab the news headlines from the object, then split the headlines and their URLs apart and then store them inside of a Python dictionary object. Then we will use the dictionary as a source to generate an HTML page in a browser.

1. Install PyWebIO using pip at the command prompt,. PyWebIO is a means to create inputs and outputs around a browser session.

pip install pywebio

2. In Thonny, create a new blank Python file and import feedparser and import three PyWebIO classes. PyWebIO has many different classes and functions, but we are interested in creating a server, outputting information to a browser and controlling the session.

import feedparserfrom pywebio import start_serverfrom pywebio.output import *    from pywebio.session import *

3. Create an object, newsfeed, and in there store the parsed BBC News feed. This can be any RSS feed that you choose.

newsfeed = feedparser.parse("http://feeds.bbci.co.uk/news/rss.xml")

4. Create an empty dictionary called news_stories. Dictionaries are Python objects that store data using a key, value system. By calling a dictionary and referencing a key, we can get the value attached to it.

news_stories = {}

5. Using a for loop with a range, grab the first five news stories and store them inside the news_stories dictionary. The title (headline) will be the key, and the URL will be the value.

for i in range(5):   news_stories.update({newsfeed['entries'][i]['title']:newsfeed['entries'][i]['link']})

6. Create a function called main. This function will handle creating the web content to be served.

def main():

7. Set the page title. This is seen in the tab / title bar of the web browser.

   set_env(title='Python For Loops RSS Example')

8. Use a for loop to iterate over every key (k) and value (v) stored in the news_stories dictionary. The for loop will end once it has retrieved all of the keys and values, it does not need a range.

   for k,v in news_stories.items():

9. Place the headline text on the page. PyWebIO’s put_text function places raw text on a web page, and we pass the function the key value, which is the headline.

       put_text(k)

10. Place the URL underneath the headline. Using put_link we generate an HTML hyperlink with the text “Click here”. The URL is created from the value stored in v.

       put_link('Click here',v)

11. Outside of the for loop and the function, start the server. Call the main function and set the port to 8080, and debug to True. It is advisable to set the port to an unused value and typically 8080 is valid. If necessary change this to another value. Setting debug to True is useful as it provides output in the Python shell, and in the browser session.

start_server(main, port=8080, debug=True)

12. Save the code as for_loop_news_dict.py and click Run. The Python shell will display the URL of the generated page.

13. Click on the URL to open in your default browser. The URL can also be viewed from another device on the network.

Complete Code Listing: Iterating With For Loops

import feedparserimport timefrom pywebio import start_serverfrom pywebio.output import *    from pywebio.session import *newsfeed = feedparser.parse("http://feeds.bbci.co.uk/news/rss.xml")news_stories = {}for i in range(5):   news_stories.update({newsfeed['entries'][i]['title']:newsfeed['entries'][i]['link']})def main():   set_env(title='Python For Loops RSS Example')   for k,v in news_stories.items():       put_text(k)       put_link('Click here',v)start_server(main, port=8080, debug=True)

Python How Tos

• How To Install Python on Windows 10 and 11
• How to use For Loops in Python
• How to Enumerate in Python
• How to Create Executable Applications in Python
• How To Remove Backgrounds From Images With Python
• How to Create Web Apps with Python, HTML and Thonny
• How To Use Raspberry Pi Camera Module 3 with Python Code

Originally created by Guido van Rossum in 1991, Python is a versatile programming language used by makers on the Raspberry Pi, system administrators in the data center, Industrial Light and Magic to bring our movies to life and behind the scenes at NASA.

Python is a great language to learn, and thanks to the Raspberry Pi for the past thirteen years there have been countless tutorials covering the gamut of programming projects.

Whether you are a Python veteran, a “pythonista” or a complete newcomer to the language, installing Python on Windows is an easy task. In this how to we will walk you through installing Python 3 on Windows (including how to install via the Microsoft Store) and show two editors, one for beginners and the other for intermediate and advanced users, and how you can get coding with this fantastic language.

Installing Python 3 on Windows 10 and 11

The installation process for Python 3 on Windows is simple, with only a couple of extra steps that we have to follow. These steps enable us to access Python from anywhere on our system and install software using its built-in package manager, pip. Installing Python in this manner enables the creation of projects that work with the operating system, for example notifications and automated system tasks.

1. Open a browser to the Python website and download the latest stable Windows installer. In the screenshots you will see Python 3.10, which was the latest version at the time of writing.

2. Double click on the downloaded file and install Python for all users, and ensure that Python is added to your path. Click on Install now to begin. Adding Python to the path will enable us to use the Python interpreter from any part of the filesystem.

3. After the installation is complete, click Disable path length limit and then Close. Disabling the path length limit means we can use more than 260 characters in a file path.

4. Click Close to end the installation.

Installing Python via the Microsoft Store

An alternative to installing Python directly from the Python website is to use the Microsoft Store. Apps in the store are approved by Microsoft and can be easily installed. The downside is that this release may be one or two versions behind the official release.

1. Click on Start and search for "store". 

2. Search for Python in the Microsoft Store.

3. Select the latest version of Python. In this case Python 3.11.4 is available from the store. 

4. Click "Get" to download and install Python to your computer. You will need to sign in to your Microsoft account. In a few moments Python will be installed and ready for use.

Running Python in Windows

1. Open a Command Prompt and type “python” then press Enter.

2. Create a short Python script that uses a for loop to print a message to the Python shell ten times. Press space four times to indent the second line, otherwise Python will produce an error. Press Enter to run the code.

for i in range(10):    print(“Python in the command prompt”)

Python comes with its own package manager, pip, that is used to install, update and remove modules of pre-written Python code. These modules provide us with extra functionality. To demonstrate we will use pip to install the pyjokes module, a collection of programmer jokes.

1. Open a Command Prompt and use pip to install pyjokes then press Enter.

pip install pyjokes

2. Open the Python interpreter.

3. Import the pyjokes module and then print a joke from the module. In our case, we got a “hip hip hurray” take on an array containing two hips.

import pyjokesprint(pyjokes.get_joke())

4. More modules can be found using the PyPi Package Index.

Beginning Python With Thonny

If you have never written a line of Python code, then Thonny is for you. Thonny is designed with beginners in mind. The simple interface means we can focus on our code. But don’t underestimate Thonny as under the hood we have tools to write code for the Raspberry Pi Pico series , Adafruit CircuitPython and many MicroPython boards, including those from Lego and the well known ESP32 boards.

1. Open a browser to the Thonny website and download the Windows installer.

2. Go to the Downloads folder and double click the Thonny file to begin installation.

3. Click "Next" and follow the instructions to Install. The install process will take a few moments to complete.

4. Search for Thonny via the Start Menu and click on Thonny to start. You can also press Enter to run Thonny.

5. Wait for Thonny to start. Thonny’s first launch can take some time to complete, subsequent boots will be much faster.

The Thonny Editor Interface

Thonny was designed with beginners in mind and this is reflected in the user interface. It is uncluttered and easy to understand.

The user interface is broken down into three areas.

The menu bar. Here we can use the conventional drop-down menus or use the icons to open, save, create files. Run the project code, and install packages and swap interpreters for working with Python, MicroPython or CircuitPython

The coding area. Here is we write the code for our projects.

The Python shell. This is a REPL (Read, Eval, Print, Loop) where we can interact with the Python interpreter and see the output of the running code.

We can easily write Python code with Thonny. The default is to write Python 3 code, to be run on our machine.

If you are starting out with Python, Thonny is an excellent choice to introduce the language.

Changing the Python Interpreter to work with MicroPython or CircuitPython

Thonny has one feature that elevates it above other beginner editors. It can switch interpreters so that one application, Thonny, can be used to write Python, MicroPython and CircuitPython.

1. Click on Tools >> Options and from the dialog box choose Interpreter.

2. Select the Interpreter from the list. The top list are all of the interpreters for Local Python (on your machine), MicroPython for Raspberry Pi Pico, Pico 2 and Pico with Wi-Fi, RP2040 (for non-Raspberry Pi boards), ESP32 / 8266,BBC micro:bit and for CircuitPython devices.

To connect a Raspberry Pi Pico, we first need a Raspberry Pi Pico running MicroPython, we've got a guide that you can follow.

To follow this part of the how to you will need a Raspberry Pi Pico.

1.  With Thonny open, connect a Raspberry Pi Pico to your computer.

2. Go to Tools >> Options and select the Interpreter tab, and then select the MicroPython (Raspberry Pi Pico) interpreter. Leave the port to automatically detect. Click OK.

3. The Python Shell (3 in the annotated screenshot) will now show an active connection to the Raspberry Pi Pico.

4. In the editor (2 in the annotated diagram) import two modules of code. The first enables MicroPython to talk to the GPIO. The second is used to add pauses to the code.

import machinefrom time import sleep

5. Create an object, led and use it to set the onboard LED as an output. For the Raspberry Pi Pico W use the line of code with ‘LED’, for the original Pico use the line of code with 25. The Pico has the LED connected to GPIO 25, but the Pico W does not.

Raspberry Pi Pico W

led = machine.Pin('LED', machine.Pin.OUT)

Raspberry Pi Pico

led = machine.Pin(25, machine.Pin.OUT)

6. Create a for loop that iterates 10 times, each time the loop runs it will toggle the LED on / off, print a message to the REPL and sleep for 0.1 seconds.

for i in range(10):    led.toggle()    print("BLINK")    sleep(0.1)

7. Click Save and save the file to your Raspberry Pi Pico as blink.py

8. Click on Run >> Run Current Script (or click on the green play button) to start the code on the Pico. The LED on the Pico will blink on and off and the REPL will show the “BLINK” message.

Intermediate Python with Notepad++

You know your stuff, and you need a lightweight editor to get your Python code done. Sure you can install Visual Studio Code, PyCharm etc. But if you just need to edit a few project files, Notepad++ is for you. Notepad++ is a Swiss Army Knife of an editor, and it works exceptionally well with Python. Here we will install Notepad++ and set it up to run our Python code at the press of a button.

Note that you will need to install the Python 3 interpreter, the steps for which are at the start of this how to.

1. Open a browser to the Notepad++ website and download the latest Windows installer.

2. In the your Downloads folder, double click on the file to start the installer.

3. Set your preferred language and click OK.

4. Select Next.

5. Select “I Agree”.

6. Click Next.

7. Click Next.

8. Click Install to begin the process.

9. Check “Run Notepad++” and click Finish to end the installation and open Notepad++.

The Notepad++ Interface

Notepad++ has a more involved user interface than Thonny, and this reflects the flexibility of the editor. Notepad++ is much more than a Python editor, we can use it to write PHP, Perl, JSON etc.

Menus. Here we can load projects, save, create macros and install plugins for specific languages.

Editor. The code for our project is created here.

Workspace. If we are working on a large project with multiple project files, we can load the folder as a workspace and have quick access to the files.

Running Python code in Notepad++

1. Create a simple Python project that uses a for loop to print a message to the Python shell.

for i in range(10):    print("Writing Python in Notepad++")

2. Save the code as for_loop.py.

3. Click on Run >> Run..

4. Click on … and navigate to the Python executable file. Select the file and the path will be added to the dialog box. At the end of the path, add -i "$(FULL_CURRENT_PATH)" to force Notepad++ to open the file. Click Save.

Example path to PythonC:\Users\LattePanda\AppData\Local\Programs\Python\Python310\python.exe -i "$(FULL_CURRENT_PATH)"

5. Create a shortcut called Python3.10 to launch the Python interpreter then click OK. We chose ALT + SHIFT + P as it didn’t conflict with other shortcuts on our system.

6. Use your shortcut to run the Python code.

Python How Tos

• How To Install Python on Windows 10 and 11
• How to use For Loops in Python
• How to Enumerate in Python
• How to Create Executable Applications in Python
• How To Remove Backgrounds From Images With Python
• How to Create Web Apps with Python, HTML and Thonny
• How To Use Raspberry Pi Camera Module 3 with Python Code

Murmurings of official Bluetooth support for the $6 Raspberry Pi Pico W have been running since early 2023. Developers favoring C/C++ received support back in February.  Today via a blog post from Raspberry Pi LTD CEO Eben Upton, MicroPython developers can now create Bluetooth projects using our favorite microcontroller thanks to the latest MicroPython build.

The Raspberry Pi Pico W's wireless chip, the Infineon CYW43439 provides both 2.4 GHz Wi-Fi and Bluetooth 5.2 over a three pin SPI bus between itself and the RP2040 SoC. The latest MicroPython update brings support for Bluetooth Classic (no ACL/SSO support just yet), BLE Central and Peripheral roles. Bluetooth Classic and BLE can be enabled individually. or at the same time. 

The good news is that you don't have to rush out and purchase a new Raspberry Pi Pico W. As this is a software update, work between Raspberry Pi, Infineon and MicroPython creator, Damien George. All you need to do is download the latest update and flash it to your Raspberry Pi Pico W. Also updated is Alasdair Allan's exceptional documentation. A book, Connecting to the Internet with Raspberry Pi Pico W illustrates just how simple a Bluetooth project can now be created using the Raspberry Pi Pico W.

With support now being added for MicroPython, it must only be a short time before it also arrives for CircuitPython.

If you’re ready to race, you should check out Donkey Car. This open-source Python library makes it super easy to get off the ground with setting up your own driveable car project. Because it’s Python-focused, you can use it with a wide variety of boards ranging from Raspberry Pi to even the Nvidia Jetson range of boards.

This platform makes it easy to not only to drive cars remotely but also integrate them with AI systems so they can drive themselves. You can interface with it using a separate computer or device (like a smartphone or tablet) and make the RC car as complex as you want. Long gone are the days of building your own tool from scratch, Donkey Car has plenty of ready-to-go features out of the box that you can build off of to customize your project the way you want.

What can you do with Donkey Car

• Build your own toy car that can drive itself.
• Drive your car with your phone or laptop.
• Record images, steering angles & throttles.
• Train neural net pilots to drive your car on different tracks.

Not only can you use the SBC of your choice, you can build the RC car of your dreams. It works with plenty of existing car kits you can find online but you can also make one from scratch. The team at Donkey Car recommends using their Donkey2 setup. It costs around $250 to get all of the components and can be assembled in just a couple of hours.

The standard Donkey Car kit is available on the Donkey Car website for $92. It includes a camera, servo driver, 3D printed frame components, as well as screws and jumper wires for assembly. You’ll still need an RC car component, an SBC (like the Raspberry Pi), an SD card, and a battery. While it doesn’t have everything you need, it’s a great starting point. There are also a few chassis made by the brand Exceed that work well with Donkey Car. You can read more about the hardware requirements in the build guide.

If you want to read more about this project or maybe even make one yourself, check out the official Donkey Car website. If you’ve already got an RC car project lying around, it might be worth tinkering with to see how well it handles the Donkey Car library.

Managing modules in Python is often handled via pip, the Python package manager which uses a repository provided by PyPi to list available Python modules. But what is there for MicroPython? There was upip, a micro version of pip, but now there is mip, the new, official lightweight package manager for MicroPython. 

Mip is designed for all MicroPython devices, be they online or offline. Devices which can connect to the Internet can be used directly via the Python Shell while offline devices can use a tool, mpremote, to install modules from your computer.

In this how-to, fee we will show you how to use mip directly on a Raspberry Pi Pico W, then offline using a Raspberry Pi Pico and mpremote. We will also go through a few handy mpremote commands.

Using mip With the Raspberry Pi Pico W

Using mip with a network connected MicroPython device means that modules can be directly installed to the device in a similar means to pip installing Python modules, and package managers in Linux.

1. Follow these steps to download the latest version of MicroPython for the Raspberry Pi Pico W. The most important steps are to download and install the UF2 firmware image and to set up Thonny. The rest are optional. Ensure that you are downloading MicroPython 1.20 or newer.

2. Open Thonny and click on the Stop button to refresh the connection. This ensures that the Python Shell is open and working correctly.

3. Create a new file. This file will contain all of the steps necessary to connect to Wi-Fi.

4. Add the following lines of code to the new file. Change the SSID and PASSWORD to match your own.

import networkwlan = network.WLAN(network.STA_IF)wlan.active(True)wlan.connect("SSID","PASSWORD")print(wlan.isconnected())

5. Save the file to the Raspberry Pi Pico W as network-connection.py

6. Click on Run to start a Wi-Fi connection. After a few seconds it should print True to the Python shell. This indicates that we have an Internet connection. If false, click Stop and then Run again.

7. Import mip, the lightweight package manager.

import mip

8. Test mip by installing a package. I chose umqtt, a MQTT module for MicroPython. Packages are installed by calling mip’s install function and passing it the name of a package. Mip uses micropython-lib as its index, Python 3’s package manage, pip uses the PyPI index.

mip.install(“umqtt.simple”)

9. Test installing a third-party MicroPython package. Mip can also be used to install third-party packages outside of the micropython-lib index. Here we pass the install function the URL for the PicoZero library from the Raspberry Pi Foundation.

mip.install(“https://raw.githubusercontent.com/RaspberryPiFoundation/picozero/master/picozero/picozero.py”) 

Using Mip With Mpremote on Raspberry Pi Pico

For MicroPython on a device with no network access, a Raspberry Pi Pico, mip will need to be used with mpremote, a tool that will communicate with the device over a USB / serial interface.

1. Follow these steps to download the latest version of MicroPython for the Raspberry Pi Pico W. The most important steps are to download and install the UF2 firmware image and to set up Thonny. The rest are optional. Ensure that you are downloading MicroPython 1.20 or newer.

2. Ensure that Python 3 is installed on your machine.

3. Open a Command Prompt and use pip to install mpremote.

pip install mpremote

4. Run mpremote and pass mip as an argument, and then specify the package name or the URL for the module. Here I am installing a package to use seven segment displays with the Pico.

mpremote mip install https://raw.githubusercontent.com/mcauser/micropython-tm1637/master/tm1637.py 

Other Useful mpremote Commands

Mpremote is a useful tool for quick tasks on a MicroPython device. We’ve detailed a few extra useful commands that will help manage a MicroPython device.

mpremote: Automatically connects to a device running MicroPython to view the output of running code. Press CTRL + ] to close the connection.

mpremote repl: Opens an interactive Python shell, a REPL (Read, Eval, Print, Loop) where a user can directly work with the hardware.

mpremote soft-reset: Reboot the attached MicroPython device. This is the same as pressing CTRL + D in the REPL.

mpremote fs : Use a series of file system commands with the MicroPython device. These commands are similar to common Unix / Linux commands.

In the example we list the contents of the flash storage, create a new file, then re-list the storage to see the new file.

MORE: Best RP2040 Boards

MORE: Best Raspberry Pi Projects

MORE: Raspberry Pi: How to Get Started

Python How Tos

• How To Install Python on Windows 10 and 11
• How to use For Loops in Python
• How to Enumerate in Python
• How to Create Executable Applications in Python
• How To Remove Backgrounds From Images With Python
• How to Create Web Apps with Python, HTML and Thonny
• How To Use Raspberry Pi Camera Module 3 with Python Code

A new version of MicroPython has been released for compatible microcontrollers. This release. version 1.20, sees support for the Raspberry Pi Pico W and brings a new package manager.

Version 1.20 brings support for the Raspberry Pi Pico W's CYW43439 Wi-Fi chip, this means that stock MicroPython can now take advantage of the $6 boards wireless connectivity. Bluetooth support is still missing, in this and the official MicroPython release. Support for Bluetooth isn't too far away now. Bluetooth support was recently added to the Raspberry Pi Pico SDK, so MicroPython isn't too far away now.

The other addition to the release is a new lightweight package manager, mip. Mip is optimized for use with embedded systems. In MicroPython creator Damien George's release post they state that "It is intended to take over the role of upip and supports installing packages from micropython-lib as well as any URL. Mip can be run directly on a device (with network connectivity) or via mpremote." Raspberry Pi Pico W users would need to ensure that their Pico W is connected to Wi-Fi and that they have access to the Python Shell (REPL) in order to use mip directly on the hardware. Raspberry Pi Pico users will need to use mpremote, a command line tool that provides utilities to communicate between a computer and a MicroPython device over a serial interface.

MicroPython, is the creation of programmer and theoretical physicist Damien George and in broad terms it is a port of Python 3 aimed squarely at microcontrollers. MicroPython has been used with a diverse range of boards (ESP32, ESP8266, W600 etc) but for some it was introduced via the Raspberry Pi Pico. 

We were keen to see if the official Raspberry Pi Pico MicroPython firmware featured support for mip. It seems that it does, the latest firmware for the Raspberry Pi Pico W, rp2-pico-w-20230427-unstable-v1.20.0-1-g82a59a824.uf2 does indeed feature mip. We were able to use mip to install a third-party MicroPython module and then directly use it, all from the Python Shell.

Python is a multi-purpose programming language. It does many things, from creating web apps to checking out who is on the International Space Station with a Raspberry Pi Pico W.
Python is easy to learn due to it being easy to read. What makes Python multi-purpose are modules of prewritten code, sometimes referred to as “libraries”. These modules bring in new functionality, for example RPi.GPIO enables Python to control the GPIO of the Raspberry Pi.

In this how to, we will use two Python modules to create a GUI application that will remove the background from an image. The first module, rembg from Daniel Gatis will remove the background from any image presented to it. The second module, easygui provides a means to create dialogs and menus using the operating system’s toolkit. So a file open / save dialog box will look exactly like those used in many other applications.

To take this project further, you can make your applications by packaging the project code into a single executable file.

Setting Up

Before we write a line of code we need to get everything in order. First we will create a folder to store the images that we will be working with. We will then open a Python editor for the coding part of the project.

1. Create a new folder on your desktop called rembg.

2. In the folder place an image that you wish to remove the background from.

3. Open your preferred Python editor, we prefer Thonny as it provides a simple user interface. Follow this guide to install Thonny.

Installing the Python Modules

In order to use Rembg we first need to download and install its Python module. This can be handled via Thonny’s built-in package manager, or via Python’s packaging tool, pip. 

Installing via Thonny

1. Click on Tools >> Manage Packages.

2. Search for rembg and click Search on PyPi. Select rembg from the returned list.

3. Click on Install to download and install rembg for Python. We have already installed rembg on our system, hence the uninstall button.

4. Repeat steps 2 and 3, but this time search for and install easygui.

Installing via Pip

If you are using another Python editor, you will need to install the Python packages using pip.

1. Open a Command Prompt and install rembg. Press Enter to start the process.

pip install rembg

2. Install easygui using pip. Easygui provides a basic user interface for file open and save operations.

pip install easygui

Writing the Code

The code is essentially very simple, with just eight lines of Python we can remove the background from any image. The underlying modules, rembg and easygui will be doing all of the heavy lifting for us.

1. From the rembg module import the remove class. This is what we shall use to remove the background.

from rembg import remove

2. From the Python Imaging Library (PIL), import Image. PIL is a powerful module that contains many different options for creating and working with images and image streams.

from PIL import Image

3. Import the easygui module and create a reference to it as “eg”. Easygui is our GUI for basic file operations. Renaming it to “eg” makes it easier to work with.

import easygui as eg

4. Create an object, input_path and use it to store the path and name of a file that we wish to remove the background from. Using easygui’s file open dialog box, we give the dialog a title, to explain what it is for. The chosen file and its path are stored to the input_path object.

input_path = eg.fileopenbox(title='Select image file')

5. Create an object, output_path and use easygui’s file save dialog box to capture the file path and save it to the object.

output_path = eg.filesavebox(title='Save file to..')

6. Create an object, input and use it to open and store the image via PIL’s Image.open function.

input = Image.open(input_path)

7. Use rembg to remove the background from the image.

output = remove(input)

8. Save the new image using the file path stored in output_path.

output.save(output_path)

9. Save the code as background_remover.py.

10. Run the code by clicking on the Run button.

11. Select the image that you wish to remove the background from. Notice that the dialog has the title that we specified in the code.

12. Navigate to the rembg folder and give the file a name and set the file format to PNG. Click Save. In our example we save the file as les-no-bg.png.

13. You may encounter an error, but this is to be expected. Download the u2net file and save it to .u2net folder in your user directory. This folder is automatically created and stored.

14. Go back to Step 10 and re-run the code. There will be no error this time so skip step 13.

15. Go to the rembg folder and your image is now ready for use.

Complete Code Listing

from rembg import removefrom PIL import Imageimport easygui as eginput_path = eg.fileopenbox(title='Select image file')output_path = eg.filesavebox(title='Save file to..')input = Image.open(input_path)output = remove(input)output.save(output_path)

Python How Tos

• How To Install Python on Windows 10 and 11
• How to use For Loops in Python
• How to Enumerate in Python
• How to Create Executable Applications in Python
• How To Remove Backgrounds From Images With Python
• How to Create Web Apps with Python, HTML and Thonny
• How To Use Raspberry Pi Camera Module 3 with Python Code

The Raspberry Pi Pico certainly put the cat amongst the pigeons in 2021, but it was missing one key feature, Wi-Fi. Sure we can hack our own solution but we had to wait until mid 2022 for Raspberry Pi to announce the Raspberry Pi Pico W in order to get official support.

The Raspberry Pi Pico W was released with a robust MicroPython firmware, but CircuitPython, our favorite microcontroller Python release, was sadly missing support. It may have taken a few months but down to the hard work of @jeffepler we now have CircuitPython 8 Beta 2 which offers Wi-Fi support for the Pico W, while retaining the familiar CircuitPython ecosystem.

To celebrate this milestone we put together a project to highlight CircuitPython on the Raspberry Pi Pico W. We’ll be working with live data from an RSS news feed, converted to JSON and then displayed on a tiny OLED screen.

Building the Circuit

For this project you will need

• A Raspberry Pi Pico W
• 128 x 32 0.91 inch OLED
• 4.7K Ohm Resistors
• Half Breadboard
• Male to male jumper wires

The circuit is essentially just the OLED screen connected to the Raspberry Pi Pico via an I2C connection. The only addition to the circuit are two 4.7K Ohm resistors which connect to the + rail and the SDA and SCL pins of the Pico. This rail is connected to 3.3V, and the resistors are used to pull the pins high, ready for sending and receiving data.

The connections are as follows

Configuring CircuitPython

1. Go to the official CircuitPython page for the Raspberry Pi Pico W and download the latest release UF2 firmware image. At the time of writing this was CircuitPython 8 Beta 2.

2. Whilst holding the BOOTSEL button, connect the Raspberry Pi Pico W to your computer. A new drive, RPI-RP2 will appear

3. Copy the downloaded CircuitPython UF2 file to RPI-RP2. This will write CircuitPython to the internal flash storage of the Pico W. A new drive, CIRCUITPY will appear.

We need a number of CircuitPython libraries before we can continue. These libraries of prewritten code add extra features to a project.

1. Download the bundle of libraries for the same version of CircuitPython as installed on the Pico W. We installed CircuitPython 8 so downloaded the bundle for version 8.x.

2. Extract the bundle to your desktop and then open the lib folder contained within.

3. Copy the following files / folders from this lib folder to the lib folder on the CIRCUITPY drive.

adafruit_bitmap_font

adafruit_display_text

adafruit_displayio_ssd1306.mpy

adafruit_requests.mpy

Working with CircuitPython

1. Download and install Thonny if you don’t have it already. Thonny is a Python editor which covers Python 3, MicroPython and CircuitPython.

2. Open Thonny and go to Tools >> Options.

3. Select Interpreter, then set the interpreter as CircuitPython, port to automatic, and click OK. Thonny will now connect to the Pico W running CircuitPython.

Our project code is made up of two files, secrets.py and code.py. The secrets.py file is essentially a Python module with two variables that will contain the SSID of our Wi-Fi access point, and the password. It is best practice to save your Wi-Fi details to a separate file called secrets.py, this reduces the risk of accidentally sharing your credentials. This process works for CircuitPython and MicroPython.

1. Create a new file and in there create two objects, ssid and password.

2. For the ssid object, assign it the name of your Wi-Fi access point / router.

ssid = “YOUR WI-FI AP NAME HERE”

3. For the password, assign the Wi-Fi password.

password = “YOUR SECRET PASSWORD”

4. Save the file to the CIRCUITPY drive as secrets.py.

Secrets.py Code Listing

ssid = "YOUR WI-FI AP NAME HERE"password = "YOUR SECRET PASSWORD"

The code for this project is contained in a file called code.py. This file will autorun when the Pico W is powered up, this is a feature of CircuitPython. In MicroPython we would name the file main.py to achieve the same result. We now start the process of writing the code that will make up our project.

1. Click on File >> Open and select the CircuitPython device. Open code.py on the CIRCUITPY drive. Delete any code in the file.

2. Import modules of pre-written code to handle pause (time) our code, set an IP address, use the Pico W’s Wi-Fi chip and to create web sockets.

import timeimport ipaddressimport wifiimport socketpool

3. Import four more modules for secure connections, to make web requests, a module with our Wi-Fi login details and a module to interact with the GPIO.

import sslimport adafruit_requestsimport secretsimport board

4. Import the final group of modules for accelerated bus access, a display library, a terminal style text module, scrolling text, and a driver for the OLED display.

import busioimport displayioimport terminaliofrom adafruit_display_text.scrolling_label import ScrollingLabelimport adafruit_displayio_ssd1306

5. Release the display for CircuitPython to use it and then specify the GPIO pins used for I2C.

displayio.release_displays()i2c = busio.I2C(board.GP1, board.GP0)

6. Specify the I2C interface and I2C address for the OLED screen on the display bus and then use that to create a display object. Don’t forget to set the width and height to match your OLED display. To find the I2C address of the OLED display, consult its datasheet or use an I2C scanner to search for it.

display_bus = displayio.I2CDisplay(i2c, device_address=0x3C)display = adafruit_displayio_ssd1306.SSD1306(display_bus, width=128, height=32)

7. Connect to the Wi-Fi using the ssid and password stored in the secrets module.

wifi.radio.connect(ssid=secrets.ssid,password=secrets.password)

8. Create a pool of sockets that we can use for connections and then create a new HTTP session to be used when making web requests.

pool = socketpool.SocketPool(wifi.radio)request = adafruit_requests.Session(pool, ssl.create_default_context())

9. Create a while True loop to run the main project code. This loop will continue for as long as the Pico W is powered on.

while True:

10. Create a banner, and save it to toms object.The Banner is a string of * followed by  “Tom’s Hardware News” then a further 10 more *.

toms = "*"*10+" Tom's Hardware News"+"*"*10

11. Create an object to handle scrolling the text stored in the toms object. The animate time handles the scrolling speed, scale is used to increase the text size, with 3 being the largest available for our 128x32 screen.

my_scrolling_label = ScrollingLabel(terminalio.FONT, text=toms, max_characters=20, animate_time=0.1, scale=3)

12. Set the position of the text (horizontal, x and vertical, y).

my_scrolling_label.x = 10my_scrolling_label.y = 10

13. Show the text on the OLED display.

display.show(my_scrolling_label)

14. Use a for loop to scroll the banner across the screen. We use the length of the text stored in the toms object, minus six to create a pleasant scroll. This will need to be tweaked to suit your banner text.

for i in range(len(toms)-6):        my_scrolling_label.update()        time.sleep(0.1)

15. Create an object, feed to store the URL of the JSON feed that contains the news headlines. We used rss2json.com to convert the Tom’s Hardware RSS feed into JSON, which can be easily worked with in CircuitPython.

feed = request.get("https://api.rss2json.com/v1/api.json?rss_url=https%3A%2F%2Fwww.tomshardware.com%2Ffeeds%2Fall")

16. Use a for loop to retrieve the first five stories from the feed.

for story in range(5):

17. Print the story’s headline to the Python shell.

print(feed.json()['items'][story]['title'])

18. Update the scrolling text to scroll the headline, with a buffer of 20 blank spaces before the text and a scale (text size) of 2.

my_scrolling_label = ScrollingLabel(terminalio.FONT, text=" "*20+str(feed.json()['items'][story]['title']), max_characters=20, animate_time=0.1, scale=2)

19. Set the position of the text (horizontal, x and vertical, y).

my_scrolling_label.x = 10my_scrolling_label.y = 10

20. Show the text on the OLED display.

display.show(my_scrolling_label)

21. Use another for loop to scroll the headline text. The iterations in the loop are set by the length of the headline, plus 21 characters to create a buffer.

for i in range(len(feed.json()['items'][story]['title'])+21):            my_scrolling_label.update()            time.sleep(0.1)

22. Finally add a sleep of 30 minutes, (1800 seconds) to set the Pico W to check for new headlines every half hour.

time.sleep(1800)

23. Save the project as code.py to CIRCUITPY and click Run to test start the code.

You should see the OLED screen come to life and scroll a banner, then the news headlines. As we saved the project to the code.py file, this code will autorun when the Pico W is powered up.

Complete Code Listing

import timeimport ipaddressimport wifiimport socketpoolimport sslimport adafruit_requestsimport secretsimport boardimport busioimport displayioimport terminaliofrom adafruit_display_text.scrolling_label import ScrollingLabelimport adafruit_displayio_ssd1306# Setup the displaydisplayio.release_displays()i2c = busio.I2C(board.GP1, board.GP0)display_bus = displayio.I2CDisplay(i2c, device_address=0x3C)display = adafruit_displayio_ssd1306.SSD1306(display_bus, width=128, height=32)wifi.radio.connect(ssid=secrets.ssid,password=secrets.password)pool = socketpool.SocketPool(wifi.radio)request = adafruit_requests.Session(pool, ssl.create_default_context())while True:    toms = "*"*10+" Tom's Hardware News"+"*"*10    my_scrolling_label = ScrollingLabel(terminalio.FONT, text=toms, max_characters=20, animate_time=0.1, scale=3)    my_scrolling_label.x = 10    my_scrolling_label.y = 10    display.show(my_scrolling_label)    for i in range(len(toms)-6):        my_scrolling_label.update()        time.sleep(0.1)    feed = request.get("https://api.rss2json.com/v1/api.json?rss_url=https%3A%2F%2Fwww.tomshardware.com%2Ffeeds%2Fall")    for story in range(5):        print(feed.json()['items'][story]['title'])        my_scrolling_label = ScrollingLabel(terminalio.FONT, text=" "*20+str(feed.json()['items'][story]['title']), max_characters=20, animate_time=0.1, scale=2)        my_scrolling_label.x = 10        my_scrolling_label.y = 10        display.show(my_scrolling_label)        for i in range(len(feed.json()['items'][story]['title'])+21):            my_scrolling_label.update()            time.sleep(0.1)    time.sleep(1800)

In a recent post on the Linux Kernel Mailing List, Linus Torvalds promised “a number of fairly core new things” in Linux kernel 6.1, and the first one seems to have appeared: as reported by The Register, the Rust programming language will be directly supported in the OS.

The news isn't exactly unexpected as patches to add Rust to Linux go back for some time, with version 9 appearing in August 2022. At the recent Open Source Summit Torvalds' keynote indicated that we should expect Rust to appear in 6.1. Right now, Rust has a group of developers working on support for the Linux Kernel and in a pull request made by Kees Cook on October 1, accepted by Torvalds, we see the first steps towards its inevitable arrival in 6.1.

Adding support for Rust adds about 12,500 lines of code to the Linux kernel, which is itself written in C, with which Rust has a certain amount of interoperability. However, GCC, the Gnu Compiler Collection, cannot compile the new language, and Clang, which can, has its own shortcomings if you want to write code for architectures other than x86 and Arm. With Rust set to receive official Linux support, and an eager community of kernel hackers, it can only be a matter of time before Rust is available to more architectures. The new kernel is expected to be available from December this year.

Some developers have already begun showing what can be done with Rust on Linux, with Western Digital’s principal engineer Andreas Hindborg showing off an NVMe SSD driver for Linux written in Rust at the 2022 Linux Plumbers Summit, which had a whole micro conference dedicated to Rust in Linux.

Rust is a general-purpose programming language influenced by C++ that was created in 2006 and hit version 1.0 in 2015. It grew out of a personal project by Mozilla employee Graydon Hoare, and was sponsored by Mozilla until 2020, when corporate restructuring caused by the Covid pandemic caused the Rust Foundation to be founded in 2021. Amazon Web Services, Huawei, Google, Microsoft and Mozilla now support the foundation, and Google supports Rust in its Android Open Source Project. The language is notable for its elegance, its zero-tolerance approach to memory safety, and the speed of its growth in popularity.

It’s also known as a high-performance language, created with the intention of marrying the flexible syntax of a high-level language with the hardware control and speed of a low-level one. Parallelism is also one of its fortes, and its strong memory safety - it notably doesn’t incorporate a garbage collector to return memory that’s no longer being referenced by a program to the system, as C# and Java do. The memory errors introduced by C programmers could be a thing of the past with Rust’s memory-safe features.

The Secure Shell Protocol (SSH) is perhaps the most well-known means to make a secure connection between a client machine (your laptop, phone or desktop) and a remote server in an office, data center or in your home network. You’ll likely use SSH if you want to get to the command line on your web hosting service or a headless Raspberry Pi. SSH is available in some form for nearly every operating system, and often it is integrated into the OS.

Most servers give you a choice of connecting to SSH via a password or via SSH keys, which are more secure. The SSH key method uses cryptographically-generated public and private keys to create an encrypted connection between devices.

Our public key is stored on the remote machine and a private key is stored on our machine. The two SSH keys are required to make a secure connection. Keys can also be used with passphrases to add another level of security, but they can also be used without, for example in automated processes.

In this how to we will learn how to create SSH keys using PuTTY, the most popular SSH client, and at the Windows Command Prompt / Linux Terminal.

Preparing the Remote Server for SSH Keys

Our remote machine can be in a data center run by a web hosting service, our office or home. Typically Linux servers such as VPS and cloud hosting will have SSH running by default, using passwords for secure logins. If this is not the case, you will need to enable SSH via the control panel for your VPS / cloud service. If you are using a home server, then it is possible that it may not be installed. If that is the case, follow these steps before moving onwards.

1. Open a terminal and check for a running SSH service on the machine. If the SSH service is running it will return Active: active (running).

sudo service ssh status

2. On the physical server, open a terminal and install OpenSSH Server. You will need to be sat in front of the machine to issue these commands.

sudo apt updatesudo apt install openssh-server

3. Start the SSH service.

sudo service ssh start

4. In your home directory create a hidden directory called .ssh.

mkdir .ssh

5. Close the connection by pressing CTRL+D or typing exit and pressing Enter.

Using PuTTY to Connect to a Remote Server Using SSH Keys

PuTTY is an application to create and manage SSH and serial connections to devices. PuTTY comes with its own key generator application and in this part of the how to we will create a public for our remote server and private key on our trusted device.

1. Download and install PuTTY. Windows does have its own command prompt, which can be used with SSH, but PuTTY is by far the most accessible means to open an SSH connection.

2. Search for puttygen and open the application.

3. Click on RSA and set the bits to 4096. Click Generate to create a key.

4. Move the mouse around the blank area of the dialog to generate a random seed for the key.

5. Create a passphrase for the key. This is advised for SSH keys that will be used in interactive sessions.

6. Save the public key as id_rsa_putty.pub to a folder called .ssh.

7. Save the private key as id_rsa_putty.ppk. The ppk file is Putty’s own private key format.

8. Highlight the public key and copy the text.

Copying the Public Key to the Remote Server

1. Launch PuTTY.

2. Enter the IP address or hostname for your remote server and click Open.

3. When prompted, enter your username and password for the remote server. Note that the password is not shown. This is a security feature to prevent “shoulder surfing”.

4. Using the nano text editor, create a new file called authorized_keys in the .ssh directory.

5. Right click and paste the public key (created in PuTTYGen) into the blank file. Save by hitting CTRL+X,then Y and Enter.

6. Log out of the SSH session by pressing CTRL + D.

7. Re-Open PuTTY and go to SSH >> Auth.

8. Select the Putty Private Key (ppk) that we just created.

9. Scroll back to Session, enter the hostname / IP address for your server and click Open to start a connection.

10. Enter your username, then the passphrase for your key. Press Enter to login.

You are now in control of the remote server, using a Linux terminal working in the Linux filesystem. To close a connection use CTRL + D or click on the X to close the window.

How To Create an SSH Key Pair via the Command Prompt / Terminal

Creating an SSH key pair from the command prompt / Linux terminal can be done with just one command and a few questions to answer. We set up the public and private keys on our client machine, copying the public key to the remote server. These steps apply to the Windows command prompt and the Linux terminal.

1. Open a Command Prompt by pressing the Windows key and search for CMD. Press Enter to run.

2. Use the ssh-keygen command to create a SSH key using the RSA key type, with 4096 bits.

ssh-keygen -t rsa -b 4096

3. When prompted to name your key, press Enter. This will save the private and public key to the .ssh directory for your named account. For example our keys were saved to C:\Users\lespo\.ssh. Linux users, the keys will save to .ssh in your home directory \home\user\.ssh

4. When prompted, give your key a passphrase as an extra level of security. A passphrase is an additional security step for SSH keys that will be used by real users (interactively). A passphrase is not needed if the SSH connection will be used in an automated script.

5. Change directory to the location of your SSH keys. Here we assume that you are in your named account. For example C:\Users\lespo is ours. Under Linux it would be /home/les/.ssh

cd .ssh

6. List the files in the directory. There should be id_rsa and id_rsa.pub.

Windows CommanddirLinux Commandls

Copying the Public Key to the Remote Server

The public key is stored on our remote server, and it interacts with the private key on our trusted machine to form a secure connection. In order to get the public key to our server we need to securely copy (scp) the file across.

1. In a Command Prompt use the scp command to securely copy the id_rsa.pub to your home directory on the remote server. You will need to know the IP address or hostname of the remote computer. In our example we copied the file to testuser@192.168.0.10:/home/testuser/

scp id_rsa.pub user@hostname:/home/username

2. SSH into the remote computer.

ssh user@hostname

3. Verify that the id_rsa.pub file is present in your home directory.

ls *.pub

4. Copy the contents of the file into a new file in the .ssh directory. Using the cat command we send the contents to the file, authorized_keys using a pipe that appends the data to the file (>>).

cat id_rsa.pub >> .ssh/authorized_keys

5. Close the SSH connection by pressing CTRL + D or by typing exit.

6. Reconnect via SSH to the remote computer. If you created a passphrase for your SSH key, you will be prompted for it.

Using SSH Keys on Another Machine

Reusing your private SSH key is possible, but it isn’t the best security practice. Losing a laptop with the key means that you will need to regenerate your keys. Best practice would be to generate a new key pair for each device that wishes to connect. Appending the public key to the authrozied_keys file on the server. That said, it is relatively easy to reuse a private key across multiple devices.

Reusing a PuTTY Private Key

PuTTY stores the private key as a PPK key and this file is all we need for a machine to connect to a remote server using our public key.

1. Go to your .ssh folder and copy the PPK file to a USB stick. Keep this USB stick safe as it can be used by anyone to gain access to your server.

2. Insert the USB stick into another computer.

3. Create an .ssh folder in your home directory. For windows this would be C:\Users\username\.ssh and Linux /home/user/.ssh.

4. Copy the PPK file to the .ssh directory.

5. Follow from Step 7 of Copying the Public Key to the Remote Server to login.

Reusing a Command Prompt / Terminal Private Key

1.  Go to your .ssh folder and copy the private key file to a USB stick. Keep this USB stick safe as it can be used by anyone to gain access to your server.

2. Insert the USB stick into another computer.

3. Create an .ssh folder in your home directory. For windows this would be C:\Users\username\.ssh and Linux /home/user/.ssh.

4. Copy the private key file to the .ssh directory.

5. Start an SSH session to the remote computer. If you created a passphrase for your SSH key, you will be prompted for it. 

ssh user@hostname

An FPGA - that’s a field-programmable gate array, a sort of reconfigurable microchip - has been shown to run a 3D, ray-traced game written in C 50 times more efficiently than an x86 CPU while using a fraction of the energy and perhaps pointing the way to future programming efficiency gains. The claims are made in a white paper [PDF] by Victor Suarez Rovere, a developer from Argentina, and Julian Kemmerer, a systems engineer from Pennsylvania, and brought to our attention by CNX Software.

The FPGA in question is the Arty A7, a Xilinx Artix-7 100T FPGA development board that sells for around $280 and features 101,440 logic cells (an FPGA’s logic cells contain a look-up table that can implement any logic function, giving the chip its programmability) on a 28 nanometer process, and which pulls less than a watt of power. The CPU it was pitted against (without, it must be said, troubling the chip’s iGPU) was a Ryzen 7 4800H, an eight-core 16-thread laptop processor that was built on a 7 nm process and has a default TDP of 45W. That's a laptop chip that's not available on its own, but the R7 4700G is currently available for about $240.

The game that was compiled to run on the two very different platforms is "Sphery Vs Shapes," and doesn’t appear to contain much in the way of plot, characters or actual gameplay, but does have lots of ray-tracing, as a shiny metallic ball bounces its way across a chessboard-like environment, which is reflected in its shiny spherical surface.

Both platforms rendered the game at 1080p and 60 frames per second without a problem, but the FPGA did it using 660 mW, while the R7 needed 35W, a difference of 53x. It is speculated that, were the FPGA to use the same 7nm process as the CPU, this figure could be six times higher.

The keys to the whole thing are Pipeline C, an invention of Kemmerer’s, and CflexHDL from Suarez. You can find them both on GitHub. "The game’s pixel rendering and animation logic is based on floating point and vector math operations. All of the game code is expressed using a clean syntax that translates directly to a digital circuit. The current target of this design is a FPGA board with Full HD digital video output, and the workflow also allows running the game in realtime on a regular PC using the unmodified source," they write in their paper. "This allows for much faster development-test iterations than with traditional hardware design tools. For the same workload, the computing efficiency resulted in more than 50X better than using a modern CPU, in a chip an order of magnitude smaller."

"Sphery Vs Shapes" stands up pretty well as a graphics demo, but what it means for the future of programming is more interesting - especially as FPGAs are going to start appearing in AMD chips. There are plans to port the whole thing to RISC-V, and to design an open-source ASIC (application-specific integrated circuit) that supports the pipeline, and there are possibilities for the world of microcontrollers too." The code can be translated to a logic circuit, run on a[n] off-the-shelf CPU, or on a microcontroller to develop hardware/software peripherals without changes to the code,” Suarez and Kemmerer write in their conclusion. "The results we obtained are readily reproducible, as materials are easy to obtain and not expensive."

Python is a glue. We can use it to join different elements of code together. As a language, Python is easy to learn, and human readable which makes it one of the most effective languages for learning and general purpose programming. Part of Python’s charm are the many modules of code which can be easily inserted into a project. 

Thonny is a powerful yet simple editor for Python and, with the release of version 4, we wanted to use it to create a project. In this how to we shall use the latest version of Thonny to create a web application that will pull Raspberry Pi stock data from rpilocator.com and use it to populate a table in our app.

RSS is a great way to share a stream of information. It can be used to serve news headlines, such as the Tom’s Hardware RSS feed or even the latest xkcd comic strip.

Nore that the RSS feed from rpilocator is not as up-to-date as the data on rpilocator.com. Think of this project as more of a notification system, than a “sniping” tool.

Installing Thonny 4.0

Thonny is the default Python IDE on the Raspberry Pi, but it is not limited to just that machine. Thonny is also available for Windows, Mac and Linux machines, and it can be used to write Python and MicroPython for devices such as the Raspberry Pi Pico W and ESP32.

1. Open a browser to the Thonny homepage.

2. Select the download for your OS. For Windows, there are a few options to choose from. The first choice is which version of Python, we would recommend the latest (3.10 at the time of writing). Next is your choice of installing Thonny to your machine, or using a portable version. We recommend installing Thonny to your machine.

3. Click on the downloaded file to start the installation.

4. Click on “More Info” to continue the installation. The new installation has a certificate that is relatively unknown and has yet to build up a reputation.

5. Click on “Run anyway” to continue.

6. Click next to continue.

7. Accept the License agreement.

8. Select the checkbox to create a desktop icon. This is an optional step, We chose not to do this as we prefer icons in the task bar.

9. Click Install to start the install process.

10. Click Finish to end the installation.

Creating Our Project with Thonny 4.0

Thonny is beginner focused, but don’t be fooled, Thonny is a competent and fully featured editor for makers. Thonny has a multi-window layout that can be edited to suit your needs.

1. Files: This is a basic file manager that can be used to open files in a project. Raspberry Pi Pico W and other MicroPython devices will open an additional pane that we can use to copy files to and from the device.

2. Coding Area: Here is where we create the project for our code. We can have multiple tabs, for multiple files.

3. Python Shell: The Python Shell (REPL, Read, Eval, Print, Loop) is where we can see the output of our code, and also interact with it.

4. Assistant: If your code has a bug, or doesn’t follow a styling guideline, it will be flagged here.

Installing Modules with Thonny

Python modules (sometimes also referred to as “libraries”) are pre-written segments of code that enable extra functionality. Popular examples include RPI.GPIO and GPIO Zero for the Raspberry Pi. Modules often abstract / simplify complex tasks. In our project we will use two modules. PyWebIO is a module to create HTML content using Python. It also creates a web server that we can use to quickly connect to our app. The second module is Feedparser, an RSS feed reader module that we shall use to read the rpilocator Raspberry Pi stock level feed.

1. Open Thonny and ensure that no projects are open.

2. Click on Tools >> Manage Packages. Thonny has a built-in GUI for the Python 3 package manager “pip”.

3. Search for pywebio.This is the module that we shall use to generate a web page using Python.

4. Click Install to download and install the module.

5. Repeat the previous steps, this time install feedparser. Feedparser is a Python module for RSS feeds.

6. Click Close to quit the dialog.

Writing the Project Code

Our goal is to create a Python project that will use the data from rpilocator’s RSS feed to populate a table. We will grab the current five entries and display them in an HTML table, created using Python.

1. In a new blank document, import two modules from pywebio. The first contains the code to start a simple web server. The pywebio.output module is used to generate HTML elements such as tables and hyperlinks.

from pywebio import start_serverfrom pywebio.output import *  

2. Import the feedparser module.

import feedparser

3. Create a function called main.

def main():

4. Inside the function create an object, “stock” and use it to store the parsed output of the rpilocator RSS feed.

   stock = feedparser.parse('https://rpilocator.com/feed/')

5. Create three empty lists, in_stock, in_stock_link and category. These will be used to store the data retrieved from the “stock” object containing the RSS data.

   in_stock = []   in_stock_link = []   category = []

6. Create a for loop that will iterate five times.

   for i in range(5):

7. Use “append” to add the stock status, link and category (reseller name) to the appropriate list. The RSS data stored in “stock” is a mixture of lists and dictionaries. For the data in a list we can use its numerical index, which is the value of i in our for loop. This will count from 0 to 4 as the for loop iterates. The data stored in a dictionary requires us to know the key (‘entries’ for example). Using the key will return its value.

       in_stock.append(stock['entries'][i]['title'])       in_stock_link.append(stock['entries'][i]['link'])       category.append(stock['entries'][i]['category'])

8. Outside of the for loop, create a pop-up notification using “toast”. The message can be a mixture of a strong, and even emojis.

   toast('🍓I found Raspberry Pi in stock!🍓')

9. Use “put_html” to write an HTML H1 heading element to the web page. We can use this function to write any HTML elements to the page, but do take note that the PyWebIO module has many different means to create specialist elements.

   put_html("
Raspberry Pi Stock
")

10. Create a list, “table” and use it to store two columns of data, taken from our in_stock, in_stock_link and category lists. The first row are the column headings Details and URL. In stock will print a brief description of what is in stock. Using “put_link” we create an HTML hyperlink, with the link text being the name of the reseller, stored in the category list, and the address stored in in_stock_link.

   table = [['Details','URL'],       [in_stock[0], put_link(category[0],url=in_stock_link[0])],       [in_stock[1], put_link(category[1],url=in_stock_link[1])],       [in_stock[2], put_link(category[2],url=in_stock_link[2])],       [in_stock[3], put_link(category[3],url=in_stock_link[3])],       [in_stock[4], put_link(category[4],url=in_stock_link[4])],       ]

11. Use PyWebIO’s “put_table” function to create an HTML table from our table object.

   put_table(table)

12. Use “put_link” to create a hyperlink under the table, in this case it takes us to the source of the Raspberry Pi stock levels, rpilocator.

   put_link('Data provided by RPiLocator',url='https://rpilocator.com')

13. Outside of the function, call PyWebIO’s “start_server” function, and pass it three arguments. The arguments are our “main” function which will create the table from the RSS data. The port is set to 8080, and debugging is enabled via the Python shell and on our web page.

start_server(main, port=8080, debug=True)

14. Save the code as RSS-Feed-Reader.py and click Run to start.

15. Click on the link in the Python shell to open the web page in your default browser.

Complete Code Listing

from pywebio import start_serverfrom pywebio.output import *    import feedparserdef main():   stock = feedparser.parse('https://rpilocator.com/feed/')   in_stock = []   in_stock_link = []   category = []   for i in range(5):       in_stock.append(stock['entries'][i]['title'])       in_stock_link.append(stock['entries'][i]['link'])       category.append(stock['entries'][i]['category'])   toast('🍓I found Raspberry Pi in stock!🍓')   put_html("
Raspberry Pi Stock
")   table = [['Details','URL'],       [in_stock[0], put_link(category[0],url=in_stock_link[0])],       [in_stock[1], put_link(category[1],url=in_stock_link[1])],       [in_stock[2], put_link(category[2],url=in_stock_link[2])],       [in_stock[3], put_link(category[3],url=in_stock_link[3])],       [in_stock[4], put_link(category[4],url=in_stock_link[4])],       ]   put_table(table)   put_link('Data provided by RPiLocator',url='https://rpilocator.com')start_server(main, port=8080, debug=True)

Python How Tos

• How To Install Python on Windows 10 and 11
• How to use For Loops in Python
• How to Enumerate in Python
• How to Create Executable Applications in Python
• How To Remove Backgrounds From Images With Python
• How to Create Web Apps with Python, HTML and Thonny
• How To Use Raspberry Pi Camera Module 3 with Python Code

There is no denying that the Raspberry Pi Pico made a big impact back in 2021. The $4 microcontroller was quickly adopted by many of the maker communities and groups and one of those was CircuitPython. CircuitPython, a fork of MicroPython which is a version of Python 3 for microcontrollers, is backed by Adafruit who are one of the partners that launched its own RP2040 range of boards. Since its creation back in 2018, CircuitPython has seen a massive investment from the community, with many projects and libraries being ported to the language.

CircuitPython is the best means to introduce Python on microcontrollers, because it’s easy to use with devices appearing in the host OS as USB flash drives. We write our code into the code.py file and we can enable external sensors, screens and inputs via a dazzling array of libraries. 

So how can we work with the Raspberry Pi Pico and CircuitPython? Typically we connect up our Pico to a PC and start writing code, but we can also build projects with a Chromebook or other Chrome OS device. With an easy-to-use programming language, cheap microcontroller and an easy-to-use OS we have the perfect platform for creativity, no matter our age or ability.

In this how to we will show you how to set up your Raspberry Pi Pico for CircuitPython, install the software to write code and communicate with your Pico, and finally we shall build a temperature sensor project.

For this project you will need

• Chromebook or other Chrome OS device
• Raspberry Pi Pico
• Half size breadboard
• LED
• 330 Ohm resistor
• DHT22 temperature sensor
• 5x Male to male jumper wires
• 10K Ohm Resistor (Brown-Black-Orange-Gold)

Install CircuitPython onto the Raspberry Pi Pico

The Raspberry Pi Pico can run many different languages, even a version of a 50+ year old language. Our focus is on CircuitPython, and installing CircuitPython on a Pico is super easy to do.

1. Download the latest version of  CircuitPython for the Raspberry Pi Pico. At the time of writing the latest version was 7.3.0.

2. Press and hold the BOOTSEL button on the Raspberry Pi Pico, then connect your Pico to the Chromebook via a USB cable.

3. Copy the downloaded UF2 file from Downloads to the RPI-RP2 drive in files. The process will take under a minute and when complete a new drive CIRCUITPY will appear in the Files browser.

Install the Tools to use CircuitPython on Chrome OS

Ideally we would have just one application which could do everything, but for now, alas we need to install two. The first is a text editor, Caret, which we can use to write CircuitPython code directly to the CIRCUITPY drive. The second is Beagle Term, a serial terminal emulator for Chrome OS.

1. Install the Caret Text Editor via the Chrome Web Store.

2. Install Beagle Term via the Chrome Web Store. 

Writing our Test CircuitPython Code on Chromebook

Before we start any electronics, let's check that we can control and communicate with the Raspberry Pi Pico. Our demo code is a simple Hello World that prints to the Python shell every second.

1. Open the Caret text editor using the Search key (the spyglass where caps lock normally resides) and type Caret. Press Enter to open. 

2.  Click on File >> Open and select code.py found on your CIRCUITPY drive. This drive is your Raspberry Pi Pico running CircuitPython.

3. Delete any code in the file.

4. Import the time module. We will use this to control the speed at which our code loops.

import time

5. Create a while True loop to continually run the code within.

while True:

6. Use a print function to print “Hello World”. Note that the code is indented by one TAB keypress or four spaces. Do not mix tabs and spaces as Python will throw an error. This is a classic example of testing code. It is a simple means that we can use to confirm that we have control of and communication with a device.

   print(“Hello World”)

7. Add a one second pause

This gives us a second to read the Hello World message.

   time.sleep(1)

8. Save your code to code.py. CircuitPython will automatically run the code each time we save.

Test Code Listing

import timewhile True:    print(“Hello World”)    time.sleep(1)

Using the Beagle Term Serial Emulator

To see the output of our code we need to run the Beagle Term serial terminal emulator. This app will connect to the Python console, running over a USB to serial connection. CircuitPython has a REPL (Read, Eval, Print, Loop) Python console which can be used to interactively work with the board and it can output information directly to the console.

1. Open the Beagle Term application using the Search key (the spyglass where caps lock normally resides) and type Caret. Press Enter to open.

2. Set your Port to your Raspberry Pi Pico. This is a little bit of a trial and error approach as we do not know the name of the port. In our tests we saw /dev/ttyACM1 for our Raspberry Pi Pico.

3. Set the Bitrate to 9600. This is the speed at which our Chrome OS device and Raspberry Pi Pico will communicate. 

4. Set the Data Bit to 8 bit, Parity to none, Stop Bit to 1 bit, and finally set Flow Control to none.

5. Click Connect to start the serial connection to your Raspberry Pi Pico. Hello World should be scrolling down the screen. If not, press CTRL+C to stop the code running, and then press CTRL+D to restart the code. 

Building a Temperature Sensor Project

The DHT22 has four pins, but we shall only need to use three of them. The sensor is relatively easy to work with. It needs 3V to power it, and the data output pin is pulled high using a 10K Ohm resistor. By pulling the pin high we ensure that the data from the sensor is read, as the pin is always “on”.

1. Insert your Raspberry Pi Pico into the breadboard so that the microUSB port is on the left side of the board. 

2. Run a jumper wire from the 3V3 out (red wire) to the + rail of the breadboard. This provides a connection to the 3.3V pin to the entire + rail. Run another wire from the GND pin to the - rail. 

3. Insert the DHT22 into the breadboard. 

4. Connect 3.3V (red wire) and GND (black wire) to pins 1 and 4 of the DHT22. The pin numbers go from left to right, as we face the plastic “frame” of the sensor. 

5. Connect the 3.3V rail to pin 2 of the DHT22 using a 10K Ohm resistor. This is our pull-up resistor for the data pin.

6. Connect the data pin (pin 2) of the DHT22 to GP15 of the Raspberry Pi Pico. Your breadboard should look like this.

Coding the Project

1. Download the CircuitPython Libraries bundle for your version of CircuitPython.

2. Go to your Downloads folder. Right click and extract the ZIP file.

3. Open the adafruit-circuitpython-bundle folder and navigate to the lib sub-folder.

4. Copy adfafruit_dht.mpy to the /lib/ folder of your CIRCUITPY drive. This library enables our Raspberry Pi Pico to work with the DHT11 and DHT22 sensors.

5. Open code.py on your Raspberry Pi Pico using the Caret text editor. Delete the test code from the file.

6. Import three modules to enable our code to access the GPIO (board), use the temperature sensor(adafruit_dht) and to control the speed of the loop (time).

import boardimport adafruit_dhtimport time

7. Create an object, dht to connect the code to the DHT22 sensor connected to GP15 on the Raspberry Pi Pico.

dht = adafruit_dht.DHT22(board.GP15)

8. Create a loop to run the code.

while True:

9. Store the current temperature in a variable called temp. The temperature is saved in Celsius.

   temp = dht.temperature

10. Create an object, text and in there store a string which will print “The temperature is    Celsius”. You’ll notice {:>8}, this is a string format which will include eight spaces in the center of the sentence. This gives us a clear space to place the temperature data.

   text = "The temperature is {:>8} Celsius."

11. Use the print function along with the text format to insert the temperature data into the gap.

   print(text.format(temp))

12. Finally add a one second pause. This enables the loop to slowly repeat.

   time.sleep(1)

13. Save the project to code.py on your CIRCUITPY drive.

14. Open Beagle Term and connect to your Raspberry Pi Pico. You should see the temperature data scroll across the screen. If not, press CTRL + C, then CTRL+D to restart the code.

Complete Code Listing

import boardimport adafruit_dhtimport timedht = adafruit_dht.DHT22(board.GP15)while True:    temp = dht.temperature    text = "The temperature is {:>8} Celsius."    print(text.format(temp))    time.sleep(1)

Related Tutorials

• How To Control Neopixels with BASIC on Raspberry Pi Pico
• How To Make a Raspberry Pi Pico Reaction Game With PicoZero

Used by NASA, ILM, Disney and hardware hackers, Python is a versatile programming language and an ideal choice for beginners. Whether you’re just  creating a “Hello World” or a full-blown application, Python needs an interpreter and a bunch of supporting libraries to work. What if we could make a GUI application, all bundled inside of a single executable file?

With auto-py-to-exe ,a project by Brent Vollebregt we can easily create our own executable Python applications. Underneath the GUI is PyInstaller, a terminal based application to create Python executables for Windows, Mac and Linux. Veteran Pythonistas will be familiar with how PyInstaller works, but with auto-py-to-exe any user can easily create a single Python executable for their system.

In this how to, we are going to create a GUI Python application using EasyGUI, and then use auto-py-to-exe to create a standalone application that will run on any Microsoft Windows system, including systems without Python installed. Linux and Mac users will need to use the underlying PyInstaller command line tool. A simple app can be created using a single line instruction. By adding more arguments we can include icons, packaged libraries etc.

For example here is the code to create a onefile application using app.py as the project code.

pyinstaller --onefile app.py

Where auto-py-to-exe differs is that we have an easier means to create an application using a GUI tool.

How to Install auto-py-to-exe

1. Open a Command Prompt by searching for CMD.

2. Use the Python package manager pip to install auto-py-to-exe.

pip install auto-py-to-exe

Create a Test Script

Our example application is a simple GUI to launch one of three applications. We use the EasyGUI Python library as it abstracts the complexities of creating a GUI application. All we need to provide is the logic that drives the application.

1. Open a PowerShell by right clicking on the Windows icon and selecting PowerShell.

2. Install EasyGUI using pip.

pip install easygui

3. Open a text editor to write the Python test script. We chose to use Notepad++, but you are free to use your favorite editor.

4. Import two Python modules, easygui and os. Easygui creates the GUI application and OS enables the code to interact with the operating system.

import easyguiimport os

5. Create two variables, one for a message (msg) to the user while the other becomes the application title.

msg = "Load application..."title="Tom's Hardware Application Starter"

6. Create a list, choices, and inside store three values which are the application names. Lists are Python’s arrays. Objects that can store multiple items. Each item has a numerical index, starting from zero.

choices = ["Google Chrome","Slack","PuTTY"]

7. Create an object, reply, to ask the user a question. In this case we use a button box from EasyGUI, each button is an option from the choices list. The chosen application is stored in the reply object.

reply = easygui.buttonbox(msg, title,  choices=choices)

8. Use a conditional statement to read the value stored in reply and compare it to three conditions. The first checks reply to see if it contains “Google Chrome” if so it will open the Google Chrome browser. The startfile function requires the use of a full file path to the application. We need to use double \\ in the path as Python uses \ to insert illegal characters into a string.

if reply == "Google Chrome":   os.startfile("C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe")

9. Use another conditional statement to check reply for slack.

elif reply == "Slack":   os.startfile("C:\\Users\\lespo\\AppData\\Local\\slack\\slack.exe")

10. Add another conditional statement to load PuTTY. Note that for PuTTY we use the os.system function as PuTTY is a registered app with the Windows path.

elif reply == "PuTTY":   os.system("putty")

11. Close the conditional test with an else condition to catch any other input.

else:   print("Done")

12. Save the file as app.py to the Desktop. If you are using an image in the application ensure that the image is also on the Desktop.

Complete Example Code Listing

import easyguiimport osmsg = "Load application..."title="Tom's Hardware Application Starter"choices = ["Google Chrome","Slack","PuTTY"]reply = easygui.buttonbox(msg, title , choices=choices)if reply == "Google Chrome":    os.startfile("C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe")elif reply == "Slack":    os.startfile("C:\\Users\\lespo\\AppData\\Local\\slack\\slack.exe")elif reply == "PuTTY":    os.system("putty")else:    print("Done")

Using auto-py-to-exe

 1. Open a Command Prompt by searching for CMD.

2. Run auto-py-to-exe from the prompt.

auto-py-to-exe

3. Click on Browse and navigate to our example Python file.

4. Set the application to use one file. This will condense the application and the supporting Python libraries into a single executable file.

5. Set the application to be Console Based. By doing this we will see any errors outputted to the Command Prompt. Once we are confident that the app works correctly, we can set this to Window Based.

6. Click on the Icon drop down and select an icon for your application. This is an optional step but it adds an extra level of quality to your application. Icons must be .ico files and we used a 64x64 pixel image as an icon.

7. Click on Advanced and, under –name, enter the name of your application. We chose App Launcher.

8. Scroll down and click on CONVERT .PY to .EXE to start the process. This will take a couple of minutes.

9. Click on Open Output Folder to open the folder containing the application.

10. Double click on the icon to run your application.

Python How Tos

• How To Install Python on Windows 10 and 11
• How to use For Loops in Python
• How to Enumerate in Python
• How to Create Executable Applications in Python
• How To Remove Backgrounds From Images With Python
• How to Create Web Apps with Python, HTML and Thonny
• How To Use Raspberry Pi Camera Module 3 with Python Code

The Adafruit blog has published an announcement confirming over 300 boards now officially support CircuitPython. These microcontrollers can be used for tons of cool projects and CircuitPython adds a new level of accessibility that makes programming modules, including the Raspberry Pi, in many ways much easier.

CircuitPython is a barebones programming language that simplifies coding by eliminating unecessary bloat and focusing only on what’s needed. To get a better idea of what it’s capable of, check out our guides on how to use CircuitPython on the Raspberry Pi and on the Raspbery Pi Pico RP2040 board.

According to Adafruit, the 300+ boards supporting CircuitPython include both official and third-party creations from companies as well as open source projects made by members of the Raspberry Pi community. There are tons of microcontrollers out there to take advantage of for your projects and some of the best ones around are RP2040 boards.

Adafruit provides a complete list of officially supported boards on the CircuitPython website. Examples include most any RP2040 board, NXP, Nordic, Espressif boards and plenty more. Check out the complete list to see if the board you want to use will work or to find alternatives for your project that support CircuitPython.

It’s not enough to support CircuitPython, special libraries are created to absolve much of the hard work and so far over 350 are available to download. There is a complete list of libraries available on the CircuitPython website including a package that bundles many of them together. If you want to see what these libraries are capable of, check out our tutortial on how to create a Simon Says game using the Raspberry Pi Pico along with the aid of CircuitPython.

The best Raspberry Pi projects are the ones you can make at home and CircuitPython easily bridges the learning gap with microelectronics. With over 300 boards now officially supported, there’s plenty of hardware to choose from and tons of inspiration from the community to help bring your project to fruition. 

We’ve got some special guests lined up this holiday for The Picast—our weekly Raspberry Pi-themed podcast. Our present to you this season is a special episode featuring the team at Adafruit scheduled for today, December 21st at 2:30pm EST / 7:30pm BST.

It’s has been an exciting year for the Raspberry Pi and consequently the rest of the community as companies like Adafruit have released a selection of new products based on the new RP2040 processor.

We'll no doubt delve into what the team has been up to this year with particular attention on the new KB2040 Key Board Driver board, which can power a custom keyboard. This is the latest creation from Adafruit and we’re just as excited as you are to see what it’s capable of.

In addition to talking about the KB2040, we’ve also got a chance to get into CircuitPython and explore the new features. If you’re not sure about where to use it, this is a great opportunity to see what it’s capable of.

Tune in today at 2:30pm EST / 7:30pm BST via YouTube or Facebook to see Adafruit and plan your last-minute wishlist. 

Math class just got even more fun! If you're lucky enough to get your hands on the new TI-84 Plus CE Python Graphing Calculator from Texas Instruments, you now have the opportunity to tinker with CircuitPython! That’s right, it’s not just for the Raspberry Pi Pico and other microcontrollers.

In a recent blog post, Adafruit confirmed the news is official and CircuitPython is definitely coming with the new calculator. This confirmation was echoed by Texas Instruments in a follow-up Tweet.

The new development is referred to as TI-Python and it's based on CircuitPython. It functions as an interpreter for Python scripts that, according to Texas Instruments, run independently from the CE OS calculations.

Adafruit dug a little deeper and discovered a few modules that come with the new TI-Python application and verified seven ranging from random number generators to ones that integrate directly with the CE OS.

The TI-84 Plus CE Python Graphing Calculator is listed available for sale in the UK but has yet to make its way to the US—although, Adafruit managed to find a teacher with one on Twitter. In the meantime, interested parties can sign up for update notifications. Read more about the TI-84 Plus CE Python Graphing Calculator in the official PDF provided by Texas Instruments. 

Adafruit has shared a new guide detailing the process for using CircuitPython libraries with MicroPython using our favorite microcontroller, the Raspberry Pi Pico.

The layer between CircuitPython and MicroPython is known as Blinka. It's a compatibility library designed to work with Linux SBCs like the Raspberry Pi Pico and the Raspberry Pi. However, the Raspberry Pi Pico microcontroller proved to be a unique challenge and hasn't been able to make use of this support until now.

Getting started is easy enough as Adafruit has supplied a full guide detailing everything you need to do. You will need the latest version of MicroPython. The instructions recommend using Thonny for this but when testing it ourselves, we opted to manually install MicroPython as Thonny had an out-of-date version listed. 

Once you've ensured your copy of MicroPython is truly the latest, you're free to go ahead and complete the guide steps which demonstrate how to use the libraries with a BME280 sensor. At this time not every library will work, we tested with a NeoPixel ring and found that it was not supported. Adafruit advised us that at the time of writing there is support for basic digital IO, I2C, SPI, UART but anything that needs a custom hardware API, including NeoPixels will not currently work. But this will change over time.

We're excited to see this new development bridge the gap between CircuitPython and MicroPython for the Pico which will hopefully save developers plenty of hassle going forward. Check out the full overview at the Adafruit website and guide to get an idea of how this new configuration works and start brainstorming your next microcontroller project. 

CircuitPython is a programming language designed to simplify experimenting with low cost boards, typically microcontroller boards made by Adafruit. CircuitPython can also be used on the Raspberry Pi and via two projects we introduce how to use CircuitPython with the Raspberry Pi. The first project is the humble LED, controlling how to blink an LED enables us to understand how we communicate and control components. The second project involves using additional components connected to the GPIO via a jumper wire to Stemma QT connector.

CircuitPython on the Raspberry Pi is transferable to other devices, such as Adafruit’s QT Py RP2040, Feather RP2040 and Pimoroni’s Keybow 2040, along with the Raspberry Pi Pico. So the skills learned here are applicable to any board that can run CircuitPython 

For This Project You Will Need

• Any model of Raspberry Pi, but for best results use a 3 / 4
• The latest Raspberry Pi OS

 Project 1

• A breadboard
• LED
• 330 Ohm Resistor (Orange-Orange-Brown-Gold is the 330 Ohm resistor color code)
• 2x male to female jumper wires

 Project 2

• Adafruit MPR121 Capacitive Touch Sensor
• 4x female to female jumper wires
• 2x crocodile clips
• 2x fruit
• StemmaQT to breadboard leads

Installing CircuitPython 

1. Open a terminal and update, then upgrade the software on your Raspberry Pi.

$ sudo apt update$ sudo apt upgrade

2.  Upgrade setuptools, a Python toolkit to manage Python package installations. 

$ sudo pip3 install --upgrade setuptools

3. Change directory to your home directory and then use pip3 to install Adafruit’s Python Shell tool. The command “cd ~” is shorthand for the home directory. 

cd ~$ sudo pip3 install --upgrade adafruit-python-shell

4. Download Adafruit’s installation script and then run the script to configure CircuitPython. During the installation it may state that you are using Python 2, it will prompt you to update, this is safe to say Yes to. 

$ wget https://raw.githubusercontent.com/adafruit/Raspberry-Pi-Installer-Scripts/master/raspi-blinka.py$ sudo python3 raspi-blinka.py

Blinking an LED 

The humble flashing LED is always the first test for a new electronics project. It enables us to be certain that our code is working and that our wiring is sound. For this project we shall wire up an LED to GPIO 17 via two jumper wires and a 330 Ohm resistor. The wiring for this project looks as follows. 

1. Open the Thonny editor and import three libraries of code. The first is “time” and this is used to control the pace of our code. The next two, “board” and “digitalio” are CircuitPython specific libraries. Board enables us to interact with the GPIO, digitalio is used to control the state of a GPIO pin. 

import timeimport boardimport digitalio

2. Using an object, led, we tell CircuitPython which GPIO pin we are using, and that it is an output. Our LED is connected to GPIO 17, which in CircuitPython is board.D17.

led = digitalio.DigitalInOut(board.D17)led.direction = digitalio.Direction.OUTPUT

3. Create a while True loop which will turn the LED on (led.value = True) and off (led.value = False) every 0.1 seconds. 

while True:    led.value = True    time.sleep(0.1)    led.value = False    time.sleep(0.1)

Your code should look like this 

import timeimport boardimport digitalioled = digitalio.DigitalInOut(board.D17)led.direction = digitalio.Direction.OUTPUTwhile True:    led.value = True    time.sleep(0.1)    led.value = False    time.sleep(0.1)

Save the code and click Run to start it. The LED should now flash on and off every 0.1 seconds. With the test complete we can move on to Project 2.

Using a Capacitive Touch Sensor With CircuitPython 

The next project requires a little more equipment, but it is no more difficult than controlling an LED. In this project we shall use an MPR121 capacitive touch sensor and a few crocodile clips to enable us to use conductive objects as inputs. 

The MPR121 is designed for microcontroller boards that have a Stemma QT connector, but with a little ingenuity we can make it work on a Raspberry Pi. The classic MPR121 example project is a banana piano, where touching a banana triggers a note to be played. For our simplified version, we will have two pieces of fruit, and each will turn the LED from the previous project, on and off.

To use the MPR121 touch sensor we will need to install an additional piece of software. Open a terminal and enter the following command.

$ sudo pip3 install adafruit-circuitpython-mpr121

The MPR121 board uses a StemmaQT connector, to use with a Raspberry Pi we need to use the breakout lead that gives us four jumper wires. They are colour coded as follows. Red to 3V, Black to GND, Yellow to SCL (GPIO3) and Blue to SDA (GPIO2). Connect the MPR121 to the Raspberry Pi using female to female jumper wires.

Using crocodile clips, connect a banana to input 0 of the MPR121, attach the other banana to input 1. Any conductive objects will work, aluminium foil and card is a cheap and easy way to make fun touch interfaces.

Open Thonny and create a new file.

1.  Import the three libraries of code. The first is “time” and this is used to control the pace of our code. The next two, “board” and “digitalio” are CircuitPython specific libraries. Board enables us to interact with the GPIO, digitalio is used to control the state of a GPIO pin.

import timeimport boardimport digitalio

2. Import two extra libraries for use with the MPR121 The first “busio” enables our code to access the I2C interface that the MPR121 uses for communication. The second clearly enables the use of the MPR121 in our code. 

import busioimport adafruit_mpr121

3. Using an object, led, we tell CircuitPython which GPIO pin we are using, and that it is an output. Our LED is connected to GPIO 17, which in CircuitPython is board.D17.

led = digitalio.DigitalInOut(board.D17)led.direction = digitalio.Direction.OUTPUT

4. Create an object, i2c, that contains the GPIO pins that are used to connect the MPR121 via I2C. Then connect to the MPR121. CircuitPython has two references for the SCL (clock) and SDA (data) pins used in I2C. These references use the default pins for I2C no matter the device. So using these references on a Raspberry Pi, QT Py RP2040 and Raspberry Pi Pico all use the default I2C pins. 

i2c = busio.I2C(board.SCL, board.SDA)mpr121 = adafruit_mpr121.MPR121(i2c)

5. Create a loop that will continually check the status of input 0, connected to a banana. If the banana is the function will return True, and then the code to print a message to the Python Shell and turn the LED on (led.value = True) will activate. 

while True:    if mpr121.is_touched(0) ==  True:        print("This banana turns light on")        led.value = True

6. Enter a  second check to read the status of input 1 which is connected to the banana used to turn off the LED. If this is pressed the function returns True and triggers the code to print a message to the Python Shell and to turn the LED off. 

 elif mpr121.is_touched(1) == True:        print("This banana turns the light off")        led.value = False    time.sleep(0.5)

With the code complete we can save the file as touch-test.py and click on Run to start the code. Now press the bananas to turn the LED on and off.

Your code should look like this

import timeimport boardimport digitalioimport busioimport adafruit_mpr121led = digitalio.DigitalInOut(board.D17)led.direction = digitalio.Direction.OUTPUTi2c = busio.I2C(board.SCL, board.SDA)mpr121 = adafruit_mpr121.MPR121(i2c)while True:    if mpr121.is_touched(0) ==  True:        print("This banana turns light on")        led.value = True    elif mpr121.is_touched(1) == True:        print("This banana turns the light off")        led.value = False    time.sleep(0.5)

CircuitPython provides the easiest way to get started on a project, thanks to a large community of makers using the language and creating libraries for components. CircuitPython is available for over 200 boards, and despite only being with us since 2018, it has been the base of many projects.

This article originally appeared in an issue of Linux Format magazine.

This Raspberry Pi Pico creation comes to us from a company called Picosoft. The Japan-based dev team has designed a Python machine known as Orange-Python that boots directly into a MicroPython interface.

Some of the best Raspberry Pi projects we've come across use a custom interface. The MicroPython program developed for the Orange-Python is very small—small enough to be flashed onto the Pico and stored locally.  

The whole operation is powered by an RP2040 on a Raspberry Pi Pico. The only extra accessories you need are a keyboard, VGA monitor and something to supply power via microUSB.

When the Orange-Python system boots, it loads into a mode called Read Evaluate Print Loop (or REPL). This is an interactive interface that works like programming on an old BASIC computer. You can see it in action on Twitter. The team even managed to program a Tetris-style demo.

The DIY kit is planned to retail for $34, ideal for makers who want to assemble the Orange-Python themselves. Pre-built kits will be sold for around $50. Check out the Orange Pico Shop for more products and updates in this one.

Thanks to the Raspberry Pi and Arduino, we are familiar with the GPIO (general purpose input/output) that enable these boards to interface with real-world electronic devices. PCs are devoid of a GPIO but boards such as Adafruit’s FT232H are available that provide that functionality via a USB port.

CircuitPython Installation 

We’ll be using Python to work with these boards. Although this may already be installed on your system, there are supporting elements you’ll need to install. These come in the form of CircuitPython, a version of MicroPython for microcontrollers such as the Raspberry Pi Pico. To setup the FT232H follow Adafruit’s installation instructions for your operating system.

Before you do anything more with your FT232H, you’ll need to solder on the headers provided. We have a great guide on how to solder header pins to your board.

To write the code for this project you will need an editor. For example you can use Notepad++, Visual Studio Code, PyCharm or whatever you are comfortable with.

Controlling the GPIO 

There’s a seemingly endless list of projects you can create when you add GPIO pins to a PC, but below we’ll show you how to code and wire a really simple one where a button causes an LED to illuminate.

1. Create a file and save it as FT232H-example.py

2. Import two modules of pre-written code. The first “board” enables the code to talk to the FT232H, the second “digitalio” is how we control the configuration of GPIO pins. 

import board import digitalio 

3. Create an object “led” which will be used to reference the LED connected to GPIO C0. 

led = digitalio.DigitalInOut(board.C0)

4. Set the LED object as an output, so that current flows to the LED from the GPIO pin 

led.direction = digitalio.Direction.OUTPUT

5. Create another object, “button.” This is used to reference the push button connected to GPIO pin C1. 

button = digitalio.DigitalInOut(board.C1)

6.  Set the button as an input. 

button.direction = digitalio.Direction.INPUT

7. Inside of a loop, set the value of the LED to match that of the button. When the button is pressed, the LED will light, when released, the LED will turn off. 

while True:   led.value = button.value

Complete Code Listing

import board import digitalio  led = digitalio.DigitalInOut(board.C0) led.direction = digitalio.Direction.OUTPUT  button = digitalio.DigitalInOut(board.C1) button.direction = digitalio.Direction.INPUT  while True:   led.value = button.value

Creating the Circuit

The circuit for this project is simple. We have an LED connected to C0, and to GND via a 100 Ohm resistor (see resistor color codes to identify). The push button is connected to 3.3V and C1. The resting state of C1 is OFF, and this state is the value used to turn off the LED.

To ensure that the push button resting state is OFF, a 10K Ohm resistor is used to pull C1 down to GND, effectively 0V. When the push button is pressed it connects 3.3V to C1, turning that pin ON and the value setting the LED to turn on. Please follow the diagram to correctly wire up your board.

Test Your Code

Open a terminal and start the code python3 FT232H-example.py press the push button to turn on the LED, release to turn off.

This story originally appeared in an issue of Linux Format Magazine.

It may not be the first block-based language for the Raspberry Pi Pico, but Piper Make definitely takes the crown of the best looking. Released yesterday, Piper Make is the latest project from Piper Learning, which previously created the Piper Computer Kit. Piper Make comes as a free online service or as part of a monthly subscription service.

Piper Make is a browser-based editor and scheme of lessons designed to introduce MicroPython via the Raspberry Pi Pico. The user interface is clearly designed for younger makers, with bright colors and large icons, but underneath all of this is a decent selection of lessons that introduce coding concepts and electronics via challenges and projects.

We went through the getting started process, first by flashing a custom firmware to our Raspberry Pi Pico and then following the first lesson to get a feel for the workflow. The block interface is extremely easy to use and automatically handles importing the libraries necessary for the blocks on offer.

Certain blocks, such as those found in Sensing, require extra components. For example, the temperature sensor block requires an I2C temperature sensor to be attached. You can purchase these sensors separately, but for a one-off payment of $30, you can purchase a starter kit with a Raspberry Pi Pico and basic components to get you started. The monthly subscription option is $20 and each month a new component is delivered to your door along with new Piper products.  

Despite this being a block-based coding platform, Piper Make is really Python. Via the Python tab on the bottom of the screen, we can switch to a view-only mode and see the project's code, which is useful for coders transitioning from blocks to text. 

Piper Make is an impressive way to introduce coding, and the monthly subscription model usefully provides curated components and lessons to support your learning. 

The Raspberry Pi Pico has been with us for just over a month and in this short space of time, there have been many projects for every level of user. But for those just starting their journey with code it can be a little daunting, and this is where block based languages such as Scratch come in to their own. Block-based Integrated Platform for Embedded Systems (BIPES) is a block based coding environment for MicroPython devices and in the latest release it now supports the Raspberry Pi Pico and other RP2040 based boards.

The BIPES project was created just over a year ago and it supports many boards such as the ESP8266, ESP32, BBC micro:bit and now the Raspberry Pi Pico and other RP2040 based boards. BIPES works with Google Chrome and writing code for a project is made easy via a web interface which is written in Blockly. Before any code can be written, we first need to enable Experimental Web Platform features in chrome://flags so that we can use Web Serial to talk to the Raspberry Pi Pico, luckily we only have to do this once. 

After setting the board to Raspberry Pi Pico and then connecting to the Pico via the Console tab we have a web REPL (Read Eval Print Loop) interface where we can write MicroPython in the browser and interact with the board. Moving to the Blocks tab we see a range of blocks categorized by their function, and there we can also see special blocks for use with the Raspberry Pi Pico. We took BIPES for a quick test and managed to flash the internal LED of the Pico in just a few minutes.

With BIPES we can write block based code, switch to Python to see the real code that makes our project and interact with REPL, all from one browser window. The BIPES blog has a selection of example project to read both digital and analog GPIO pin values, control LEDs with PWM and work with a temperature sensor. 

It is still early days for Raspberry Pi Pico and BIPES, some key functionality, notably managing Python files on the Pico. Right now we can download our block based code as an XML file and share it with others who can upload it to the BIPES site which converts it back to blocks that can be written to another Pico.

If you've already got a Raspberry Pi Pico and some eager makers in your home, then BIPES could be the tool to introduce the world of making to a younger audience.