Linux Hacks

552 Articles

Running Octoprint On A PinePhone Turns Out To Be Pretty Easy

November 30, 2021 by 11 Comments

3D printer owners have for years benefitted from using Octoprint to help manage their machines, and most people run Octoprint on a Raspberry Pi. [Martijn] made it run on his PinePhone instead, which turned out to be a surprisingly good fit for his needs.

While [Martijn] was working out exactly what he wanted and taking an inventory of what Raspberry Pi components and accessories it would require, it occurred to him that his PinePhone — an open-source, linux-based mobile phone — would be a good candidate for his needs. It not only runs Linux with a touchscreen and camera, but even provides USB, ethernet, and separate DC power input via a small docking bar. It looked like the PinePhone had it all, and he was right. [Martijn]’s project page gives a walkthrough of the exact steps to get Octoprint up and running, and it even turns out to not be particularly difficult.

[Martijn] is no stranger to hacking his PinePhone to do various things; we’ve already seen him add thermal imaging to his PinePhone. For those of you who are intrigued by the idea but don’t own a PinePhone? Check out the octo4a project, which allows running Octoprint on Android phone hardware.

Linux Fu: The Ultimate Dual Boot Laptop?

November 30, 2021 by 37 Comments

I must confess, that I try not to run Windows any more than absolutely necessary. But for many reasons, it is occasionally necessary. In particular, I have had several laptops that are finicky with Linux. I still usually dual boot them, but I often leave Windows on them for one reason or another. I recently bought a new Dell Inspiron and the process of dual booting it turned out to be unusually effective but did bring up a few challenges.

If you ever wanted a proper dual-booting laptop, you’ll be interested in how this setup works. Sure, you can always repartition the drive, but the laptop has a relatively small drive and is set up very specifically to work with the BIOS diagnostics and recovery so it is always a pain to redo the drive without upsetting the factory tools.

Since the laptop came with a 512 GB NVMe drive, I wanted to upgrade the drive anyway. So one option would have been to put a bigger drive in and then go the normal route. That was actually my intention, but I wound up going a different way.

Continue reading “Linux Fu: The Ultimate Dual Boot Laptop?” →

Firefox logo displayed on screen

Firefox Brings The Fire: Shifting From GLX To EGL

November 23, 2021 by 55 Comments

You may (or may not) have heard that Firefox is moving from GLX to EGL for the Linux graphics stack. It’s an indicator of which way the tides are moving in the software world. Let’s look at what it means, why it matters, and why it’s cool.

A graphics stack is a complex system with many layers. But on Linux, there needs to be an interface between something like OpenGL and a windowing system like X11. X11 provides a fundamental framework for drawing and moving windows around a display, capturing user input, and determining focus, but little else. An X11 server is just a program that manages all the windows (clients). Each window in X11 is considered a client. A client connects to the server over a Unix process socket or the internet.

OpenGL focuses on what to draw within the confines of the screen space given by the window system. GLX (which stands for OpenGL Extension to the X window system) was originally developed by Silicon Graphics. It has changed over the years, gaining hardware acceleration support and DRI (Direct Rendering Interface). DRI is a way for OpenGL to talk directly to the graphical hardware if the server and the client are on the same computer. At its core, GLX provides OpenGL functions to X11, adds to the X protocol by allowing 3d rendering commands to be sent, and an extension that reads rendering commands and passes them to OpenGL.

EGL (Embedded-System Graphics Library) is a successor of GLX, but it started with a different environment in mind. Initially, the focus was embedded systems, and devices such as Android, Raspberry Pi, and Blackberry heavily lean on EGL for their graphical needs. Finally, however, Wayland decided to use EGL as GLX brought in X11 dependencies, and EGL offers closer access to hardware.

When Martin Stránský initially added Wayland support to Firefox, he used EGL instead of GLX. Additionally, the Wayland implementation had zero-copy GPU buffer sharing via DMABUF (a Linux kernel subsystem for sharing buffers). Unfortunately, Firefox couldn’t turn on this improved WebGL’s performance for X11 (it existed but was never stable enough). Nevertheless, features kept coming making Wayland (and consequently EGL) a more first-class citizen. Now EGL will be enabled by default in Firefox 94+ with Mesa 21+ drivers (Mesa is an implementation of OpenGL, Vulkan, and other specifications that translate commands into instructions the GPU can understand).

Continue reading “Firefox Brings The Fire: Shifting From GLX To EGL” →

PinePhone Speed Up Takes Soldering

November 19, 2021 by 19 Comments

It is no secret that we like a good hack and [Federico Amedeo Izzo] explains a hack for the PinePhone that can double the speed used for the device’s memory chips. Like many good hacks, it all started with a question. [Federico] was reading a review of the PinePhone Pro (the source of the image for this post) and apparently, the eMMC memory in that phone clocks in at about 150 MB/s. The original phone gets about 50-80 MB/s.

Reading some datasheets, it looked like the same chips are in both phones and should support not only DDR52 mode — the mode the original phone uses — but also HS200 and HS400 modes which top out at 200 and 400 MB/s, respectively. But there was one problem.

Continue reading “PinePhone Speed Up Takes Soldering” →

Linux: Coming Soon To M1 Macbooks

November 17, 2021 by 62 Comments

Regardless of the chipset or original intended use of any computer system, someone somewhere is going to want to try and run Linux on it. And why not? Linux is versatile and free to use as well as open-source, so it’s quite capable of running on almost anything. Of course, it takes a little while for the Linux folk to port the software to brand new hardware, but it’s virtually guaranteed that it’s only a matter of time before Linux is running on even the most locked-down of hardware, like the M1 MacBooks.

[Hector Martin] aka [marcan] has been hard at work getting Linux up and running on the latest Apple offerings with their ARM-based M1 processors. Since these are completely divorced from their x86 product line the process had to be worked from the ground up which included both booting Linux and modifying the kernel to include support for the hardware. [marcan] has a lot of hardware working such as the USB ports and the SD card slot, and notes that his setup is even compatible with the webcam notch included in the latest batch of MacBooks.

There are a few things still missing. He’s running Arch and doesn’t have the GPU configured yet, so all of the graphics are rendered in software. But he has put the computer through the wringer including running some computationally-intense software for nearly a full day before realizing that the machine wasn’t charging, which did not make much difference in performance. These machines are indeed quite capable with their new ARM chipsets and hopefully his work going forward will bring Linux to the rest of us who still use Macs even if they don’t want to run macOS.

Linux On The Windows 11 Desktop

November 10, 2021 by 38 Comments

A month ago Microsoft officially released Windows 11. One of its features is the ability to run Linux GUI applications side by side as peers to normal Windows desktop apps. [Jim Salter] of Ars Technica took a closer look and declared it works as advertised.

This is an evolution of the Windows Subsystem for Linux (WSL), which has existed for a few years but only in command-line form. Linux being Linux, it was certainly possible to put visuals onscreen, but doing so required jumping through some hoops and dealing with limitations. Now “WSLg” gives a smoother and more accessible experience.

While tremendously valuable for those who need it, WSLg is admittedly a niche feature. The circumstances will be different for different needs. Around these parts, one example is letting us work with pieces of proprietary Windows software (such as low level hardware drivers or hardware-specific dev tools) while still retaining Linux tools for the rest of our workflow.

It’s also interesting to take a peek behind the scenes for an instructive look at bridging two operating systems. A Microsoft blog post describes the general architecture, where we were happy to see open-source work leveraged. And by basing this work on Wayland, it is more forward-looking than working with just X11.

The bad news is that WSLg is limited to Windows 11, at least for now. WSL users on Windows 10 will have to continue jumping through hoops (We described one method using X11.) And opening this door unfortunately also opened the door to security issues, so there’s still work ahead for WSL.

Linux Fu: Automatic Header File Generation

November 8, 2021 by 22 Comments

I’ve tried a lot of the “newer” languages and, somehow, I’m always happiest when I go back to C++ or even C. However, there is one thing that gets a little on my nerves when I go back: the need to have header files with a declaration and then a separate file with almost the same information duplicated. I constantly make a change and forget to update the header, and many other languages take care of that for you. So I went looking for a way to automate things. Sure, some IDEs will automatically insert declarations but I’ve never been very happy with those for a variety of reasons. I wanted something lightweight that I could use in lots of different toolsets.

I found an older tool, however, that does a pretty good job, although there are a few limitations. The tool seems to be a little obscure, so I thought I’d show you what makeheaders — part of the Fossil software configuration management system. The program dates back to 1993 when [Dwayne Richard Hipp] — the same guy that wrote SQLite — created it for his own use. It isn’t very complex — the whole thing lives in one fairly large C source file but it can scan a directory and create header files for everything. In some cases, you won’t need to make big changes to your source code, but if you are willing, there are several things you can do.

Continue reading “Linux Fu: Automatic Header File Generation” →