FOSSPicks

UX designer

Penpot

Penpot is a tool that helps designers create and prototype a user interface (UI). A little different from the desktop and command-line utilities that typically fill these pages, Penpot is a web application, designed to run in your web browser and, most usefully, online. Like WordPress, Nextcloud, and Home Assistant, the online element in Penpot is an essential feature that performs such an important role that the application is worth investigating, regardless of how it presents itself. And like those other brilliant web apps, it has a huge Linux bias and a commitment to open source.

Over the past few years, if you worked on any project that required a designer, it's likely the designer will have used a prototyping tool like Penpot. They're used to sketch up various UI designs, present them to the team, make changes, and eventually fix those changes so that developers can start adding whatever functionality is required. This is why similar prototyping tools work best when they're hosted online: It allows a project's various "stakeholders" to access the designs, make their own suggestions, and leave feedback. Penpot can do all of this and a lot more.

While Penpot is a web app and its developers offer their own portal, which is currently free to use, the open source version can be easily downloaded and self-deployed via a Docker image. This also happens to be the default development environment for anyone who wants to tinker with the code. Despite loading via a web browser, the application itself operates much like Inkscape or Scribus, only with additional social and prototyping features. There are shape drawing tools, a freehand mode, paths, curves, images, and text boxes. All are tightly bound to a grid, object boundaries, many alignment modes, and accessible data values for every element. These can then be grouped into reusable objects.

The UI is remarkably quick and responsive. As you might expect from a tool for designers, it really has been beautifully designed. From the icons and expandable menus to the comprehensive example documents that are used to onboard you to the workflow and functionality, you soon forget you're using a web application. In common with other user experience (UX) tools, when you're done with design, it's also possible to build some skeleton functionality into your creations to see how it feels to interact with your proposed interface. This is the prototyping element, and it lets you link one element to another so that transitions can be made with a click. It's simple but likely to be developed further in the future, considering that Penpot is still alpha software.

When it comes to sharing your ideas, you can create teams to allow other users to access specific projects, and projects are chosen from a dashboard before being loaded into a workspace, which is where the creating and editing happens. The open source element in Penpot is obviously important too, not just because one of the first panels you're presented with invites you to get involved with the code development, but also because Penpot makes fantastic use of the SVG format. Penpot uses it for import and export, along with wide browser compatibility and performance. Using SVG means you're never going to be locked into a single application.

Project Website

https://penpot.app/

1. Dashboard and workspaces: Projects are opened from the dashboard into the workspace. 2. Hosted: Host your own project and access Penpot from a browser. 3. Properties: Exact values for every element can be edited. 4. Assets: Easily access styles, assets, buttons, and properties. 5. Canvas: Zoom in and out, group elements, and easily arrange them. 6. Prototyping: Create one-click actions to see how the application might feel and behave. 7. History: Every action is saved and can be recalled or reset. 8. Drawing tools: Forget you're in a browser and draw just like you're using Krita or Inkscape.

System monitor

ProcMon

If you've ever had the pleasure of using Microsoft Windows, you might have run a Microsoft tool called Process Manager (ProcMon) to find out why your system is running slowly. Unlike other monitoring tools that might show you which processes were consuming the most resources, ProcMon focuses on which system calls (syscalls) a process is currently working on, enabling you to perform some analysis on what is going on behind a simple process name. Syscalls represent the functions that an application or process has requested to be run by the operating system or kernel, such as reading or writing data, allocating memory, waiting (polling) for an interrupt or a message, or opening a device. Monitoring which syscalls a process is running is a great way to troubleshoot your own projects or to determine whether a random process might be failing, stalling, or performing badly. It's more granular than the process-wide analysis offered by tools like top or a desktop system monitor.

Microsoft has ported its famous ProcMon to Linux and placed the source code on GitHub from where it can be easily built and executed. There's even a command-line option to build a deb package. ProcMon Linux runs within a terminal using curses and presents much of the same information as its desktop Windows counterpart. Most importantly, this means showing the resource-hungry syscalls, the process IDs they're sharing, the operations they're performing, and how much of your system time they're consuming. It's a fascinating insight into what various applications might be doing, such as Chrome, X11, or your Windows compositor, and it shows a different side to resource usage than the normal top kind of view. With specific command-line arguments, you can choose specific process IDs to trace, track only specific syscalls, and output a log of traces to an external file, which can be later reread and run through for analysis. ProcMon is definitely a refreshing change from normal Linux resource monitors and a useful addition to your $PATH.

Project Website

https://github.com/Sysinternals/ProcMon-for-Linux

On Windows, ProcMon might be ideal for identifying malware. On Linux, it's perfect for feeling smugly free of malware.

Storage monitor

diskgraph

These days, there are too few purely C-coded utilities that are useful, modern, self-contained, compiled in seconds, and relatively easy to understand. However, diskgraph is an instantly compiled command-line tool that draws a chart in your terminal showing storage throughput for both input and output operations. Each measurement is represented by a character-sized square that represents a 500ms interval, with the y-axis showing an automatically scaled bandwidth (amount transferred over time) and the x-axis showing the time frame. The blocks will scroll from the right to the left as time progresses so you can more easily see fluctuating load conditions as you read and write files, allowing you to easily see periods of peak and low transfer and how your hardware is performing. It's very simple, but it presents information that isn't easily visualized any other way.

The executable takes only a single argument, the storage device, with no further options to configure how the utility looks or behaves. But this is an ideal opportunity rather than a limitation, because the entire project's code is contained within a single .c file of just less than 500 lines of code. This makes it ideal for study and also for user-developed modification such as extra arguments. It would be trivial to change the character I/O blocks into bars, for instance, or to add some other visualization method or to change the way the bandwidth is calculated. It's exactly the kind of project to start with if you want to investigate more serious system-level Linux programming, maybe ultimately leading even to kernel development. The code is relatively easy to understand, operates at a low level, and should be safe to modify – diskgraph only reads from devices rather than writing to them without requiring special privileges.

Project Website

https://github.com/stolk/diskgraph

Diskgraph is a super simple tool for monitoring storage I/O, but it's also eminently hackable and easy to understand.

Bookmark manager

Shaarli

There was a time, many years ago, when managing web browser bookmarks was incredibly important. This was before Google got good, and you could seldom find the site you'd previously found or remember how you got there. Instead, you'd fruitlessly hunt through your browser history trying to remember the train of thought that led you to the site you wanted to revisit. If you had the foresight to bookmark the site, the problem was solved until you bookmarked too many sites and failed to organize them, leading you back to the rapidly improving Google. But bookmarks haven't gone away, especially now with many of us experimenting with other search providers and trying to keep as much personal preference off the Internet as possible. Consequently, it can still be a good idea to control and manage your own bookmarking regime.

We recently looked at a brilliant tool and local bookmark server called buku, but Shaarli has a slightly different take on the same problem. Rather than relying on a system command to handle the bookmarks and a server to present them, Shaarli handles everything from a web server using PHP. Installation is straightforward if you already have a server running, and the documentation excellently guides you through creating a virtual host in your configuration. There are also instructions for using Docker. When the service is up and running, you simply create an account, log in, and start adding bookmarks. The great thing about Shaarli is that these bookmarks can (optionally) be public and appear listed on the landing page so that anyone with access to your server can see them. Thanks to the search and tagging, a daily feed and even RSS provision, Shaarli can become a hub of activity and a central part of using the Internet outside of the big search and bookmark providers. Locked behind a firewall, Shaarli could be a useful local sharing hub for your family and friends.

Project Website

https://github.com/shaarli/Shaarli

While we wouldn't recommend running Shaarli on the Internet, it's a great way to save and share bookmarks on a home network.

Music identifier

Music Radar

Even though we're used to the idea of a tool that can listen to music and identify it, especially on a smartphone, the reality is often different from the idea. Background noise, poor recording quality, and limited access to the clip you want to identify all inhibit the ability of these tools to do their job. As a result, there was a genuine "jaw-dropping" moment when we first tested out Music Radar on a piece of music. The piece was a rather obscure ambient track from 2020 by the artist Helios entitled "One And The Same." It has no drums, no melody, no repeating sections, no verse, and no chorus. It consists mainly of textured soft clusters of droning synthesizer chords and, at times, sounds almost identical to Brian Eno's 1983 classic, "Deep Blue Day." Music Radar listened to about seven seconds of "One And The Same" and perfectly identified it, proudly presenting the result with a thumbnail of the album cover, the title, artist, and year, along with links to search YouTube, play it on Spotify, and play a preview – seriously impressive.

This power has a price, though. The analysis and results come via API access to audd.io, which permits only a few requests per day. Music Radar isn't affiliated with this service, but you can create a token for yourself by creating an account and pasting the key into the Settings pane. This window also allows you to set the default recording time and which theme to use. Thanks to some clever choices, the application's main functionality couldn't be easier to use. There are two options for sourcing the audio: a connected microphone or whatever you're using to listen to music, such as a speaker. A speaker allows Music Radar to capture the audio at the highest quality, unaffected by external noise or microphone input, and surprisingly requires no messing around with PulseAudio. However it does this, regardless of the online AI magic it must perform, it just works.

Project Website

https://github.com/keshavbhatt/music-radar

Music Radar is brilliant if you listen to Internet radio and need to identify a track.

Git GUI

GitAhead

Most of us agree that Git is wonderful, and it's now being used everywhere, even in places not routinely handling code. Documentation, design, and even configuration files can often benefit from using Git, which can create a problem when non-technical people need to wrestle with some of Git's more esoteric features. This is where a graphical interface can help by promoting best practices, safe-guarding from mistakes, and by simply visualizing normally abstract commands. The problem is, we've yet to find a Git GUI that's able to do all of this without becoming more complex than the git command itself. But GitAhead is a very strong contender, especially in one area of Git's functionality: commit history. Understanding and visualizing a Git repository's commit history can help you to understand exactly what's happening when you later create and merge pull requests, or release branches, or even resolve conflicts with the git command itself.

GitAhead excels at this. It will connect directly with remote repositories on GitHub, Bitbucket, Beanstalk, and GitLab or access local repositories directly. These are saved into a quick access panel on the left and, by default, the last commit is shown in the main view when a repository is selected. The main view shows either an inline diff of the changes between this version and the previous, or a tree view of the file structure holding those changes. In all views, a middle pane displays a navigable log of the commit history. Each commit is clearly shown along a colored timeline for each branch, making it easy to see what came from where. You can also create a new branch, squash, merge, stash, checkout, and rebase from the menu system. It works brilliantly, takes much of the guesswork out of managing a Git repository, and is also a beautiful example of interface design.

Project Website

https://gitahead.github.io/gitahead.com/

Visualize branches and commits easily, as well as pull, merge, and rebase, with the easy-to-use GitAhead Git client.

Internet radio client

Tuner

Maybe it's because many of us have been dreaming about traveling and experiencing other cultures, but there's been a resurgence in high-quality desktop Internet radio applications. We recently looked at the fantastic Shortwave, for example, which made tuning into a global network of radio stations easy, and here we have the equally wonderful Tuner. Tuner isn't designed specifically for global radio, but it can access a huge library of available stations through its search function, along with quick access to a variety of genres, trending stations, and a discovery tab. It describes itself as a "minimalistic" Internet radio application, so it's fitting that Tuner makes such brilliant use of the GTK3+ toolkit and its human interface guidelines to reduce the screen clutter to only those buttons you need.

The top window border contains nearly all the playback functionality. It embeds the play, pause, and star (for favoriting a station) buttons. To the right of these are the station details, a search field, and a tiny configuration menu. The main window below is populated with either search results or curated selections from the genre list. The station URLs themselves are retrieved online using the API and catalog on radio-browser.info, but unlike with Shortwave, this can be changed by setting an environment variable. This allows you to host your own list of stations, for instance, or use more than one source for searches and recommendations. The application was developed as a COVID-19 project by its developer after moving from macOS to Linux, and this helps explain why its design is so clean, minimal, and functional. In fact, the project has proven so successful that the developer has been overwhelmed by the response and requirements of the community and is now looking for developers and package maintainers to help. If you're interested, take a look at the project's GitHub page.

Project Website

https://github.com/louis77/tuner

Tuner has one of the best Gnome interfaces we've seen; it is a brilliant way to explore the global Internet radio network from your desktop.

Development environment

Arduino IDE 2

The original Arduino IDE started life in 2005, before the launch of Twitter and before Facebook dropped its university-only invite policy. This text editor based IDE has since become synonymous with Arduino devices, being used for everything from uploading simple sketches (really, C files) to device management and fully fledged application development. At its heart, however, it was always a text editor with a lower panel for debug and compilation output, with few features to help with larger projects. This is why some projects created their own makefiles to automate the build, and partly why the arduino-cli tool was developed to unshackle the build process from the editor. More recently, arduino-cli has led to some excellent integration with Visual Studio (VS) Code, which can now develop, debug, build, and flash Arduino projects to the hardware better than the original Arduino IDE.

This means now is the time for an ambitious update to the humble Arduino editor, and the Arduino team has already been working on it for a couple of years. Gone is the Java dependency, gone is the one-window-per-file view, and gone is debugging via printing string messages. It's all been replaced by Arduino IDE 2, a modern Eclipse Theia and Electron-based front end to all the decoupled functionality of arduino-cli, transforming the default Arduino experience. This unification on a single build platform, arduino-cli, means you can choose whichever tool works best for you and easily migrate between them as your needs change. Edit from the IDE one day and build from VS Code the next.

The biggest difference is in the editor itself. It now uses an adaptive design that will scale to fit whatever space you want to give it. It feels similar to VS Code without the complexity or Microsoft telemetry, which is no surprise because they both use the same architecture. There are autocomplete suggestions as you type, allowing you to easily navigate between symbols and definitions in your code and refactor names at will. A left-hand pane includes tabs that show search results, the board manager, the library manager, and a debugging console. But it's this debugging console that represents the other biggest change in functionality, because it finally drags Arduino development into the 21st century. Debugging can now be performed "live," in real time, allowing you to run your code on a board while viewing its execution within the IDE.

For this to work, you do need one of the more recent boards (MKR boards, Nano 33 IoT, Nano 33 BLE, Portenta, and Arduino Zero devices) or a bridging device such as the SAM-ICE JTAG to interface. This is because debugging now uses two-way communication while executing your code, a process that was previously impossible. In the old IDE, after the code had been uploaded to the board, the only interaction between your device and the IDE was through the serial connection, often leaving developers to debug their code using println statements. The new process allows you to introspect the state of your application, including its variables and functions as they're lighting up LEDs, scanning inputs, and producing voltages, just as you do when debugging software running on your computer. All of this hopefully sets up the next generation of the Arduino IDE for the next 15 years of development, in that useful junction between simple editor and fully fledged IDE, and we can't wait to see what features they add next.Project Website

https://github.com/arduino/arduino-ide

One brilliant thing about the new Arduino IDE is that you can finally change the font size and theme without messing around with configuration files and CSS.

Debugging is no longer reliant on printing serial output but can instead use two-way communication while your code is executing on the device.

Chess simulator

Lucas Chess

It's been more than 20 years since IBM's Deep Blue defeated a reigning (human) world chess champion, and chess has since been through various troughs and peaks in popularity. But thanks to recent circumstances, and a particularly popular episodic streaming production, the humble game of chess is going through a huge renaissance. It's become difficult to even buy a decent chess board. Fortunately, there are plenty of computer chess engines and clients to choose from on Linux, including the widely regarded and ported PyChess with the Stockfish back end. But one of the most popular open source implementations has never had official support on Linux, until now. And that's the brilliant Lucas Chess. What makes Lucas Chess so popular, despite its antiquated graphics and long development periods, is the quality of the chess it plays. This isn't because it plays a particularly strong game of chess, although it can – Deep Blue and its descendents have also solved that problem – but because it plays a natural game of chess that can feel like playing a human. Alongside this, Lucas Chess also includes some of the best training modes to help you improve your game, which are difficult features to find on Linux.

Lucas Chess includes 61 different playing engines, all with differing levels of difficulty, from 0 to 3300 in the Elo difficulty rating scale. There are even special engines for younger players, with names like Monkey, Lion, and Stephen, and there are the brilliant training modes using the Stockfish or Komodo engines. You can pit your skills against specific challenges or receive scored feedback and analysis of every move you make. There are memory games, coordinate tests, a mode to help learn by repetition, and training positions, plus other tests and starting and ending resources for stronger players. The user interface is simple but includes a huge list of themes that can change the board, colors, and piece designs. It may all look a little austere, but then chess is old.

Project Website

https://lucaschess.pythonanywhere.com/home

Until now, if you wanted to play Lucas Chess on Linux, you needed to use Wine, but there's finally a version that runs natively.

Finding game

mki3dgame

Smartphones, iPads, and Android tablets have rekindled popularity for all kinds of old-fashioned games, and in particular, games that involve drawing, coloring, and finding things. The weirdly named mki3dgame is a finding game, but rather than constraining itself to the limitations of a two-dimensional plane, mki3dgame hides objects for you to find within a 3D realm. Its name actually comes from the MKI 3D Rapid Modeler, a web-based, open source, and keyboard-driven 3D modeling tool, which was used to create all the 3D shapes in the game. The idea behind the game itself is to find and frame multiple red tokens hidden within the 3D environment using the targeting reticule to center the token and the direction keys to move toward the token so that you collide to collect it.

The command-line output of the game helpfully lists the various keyboard controls for moving the player through the 3D space. It also reports when a token is collected and how many more you have to find. There are also keyboard shortcuts for changing the graphics and loading a new random level. Sections of the targeting reticule can be clicked on to move or rotated without needing a keyboard, gamepad, or joystick, which makes the game a fun distraction. It can be quite difficult, though, as you move through the levels trying out different angles and approaches to reveal the tokens, and it's a process that's made more difficult by multiple monsters also moving through the environment, ending your attempt if you make contact with them. The latest release of the game includes four different types of these monsters and 32 stages to complete, which makes finishing the whole thing a considerable challenge. But if you enjoy finding things and want to improve your spatial awareness from a 2D dimensional screen, it's definitely worth the installation.

Project Website

https://github.com/mki1967/mki3dgame

Apart from the game itself, mki3dgame is a great project to study 3D and Golang programming.