Language Selection

English French German Italian Portuguese Spanish

Site Map


Community blog and recent blog authors at Tux Machines.





More in Tux Machines

Software: FreeCAD, Text Editors, Man-Pages and Kiwi TCMS

  • Checking out FreeCAD

    Our look at running a CNC milling machine using open-source software led me to another tool worth looking at: FreeCAD. I wasn't previously familiar with the program, so I decided to check it out. In this article I will walk through my experiences with using FreeCAD for the first time to do a variety of CNC-related tasks I normally would have used a commercial product for. I had varying degrees of success in my endeavors, but in the end came away with a positive opinion. FreeCAD is an LGPL v2+ licensed CAD and CAM program written in Python and C++. The first release of the project was in 2002, and its last stable version 0.18.4 was released in October 2019. The project's GitHub page indicates that it has 271 contributors with new commits happening often (generally more than 50 a week). Beyond code contributions, FreeCAD has a welcoming community with active forums to answer any questions users might have along the way. FreeCAD is designed to be cross-platform, supporting Linux, macOS, and Windows, with binary releases provided by the OS-independent package and environment management system Conda. I decided to take on a relatively simple CNC project: milling a new street-address sign for my home. The plan called for a 700mm x 150mm sign, and I decided to mill it out of a plank of maple wood. The design I have in mind is pretty straightforward, so it should be a great way to put FreeCAD through a test on a real project. I also looked at using FreeCAD for taking existing models that are available online with an open license and importing them for milling (in this case, a wooden spoon). It is worth noting that before this effort I had never used FreeCAD before. My personal goal is to become fluent enough with FreeCAD that I can replace my dependence on the commercial CAD software I presently use in my design work. The goal of this article, however, is to share what my experience with FreeCAD was, and provide a glimpse of FreeCAD from the perspective of an inexperienced user.

  • 9 Best Emacs-Like Text Editors

    Over the years, one of the most emotive areas in the world of Linux is the choice of text editor. Some people are strong advocates of Vim, others prefer Emacs. And there’s tons of other text editors available with strong backing. Having robust opinions is the way the land lies in Linux. Emacs has a long and revered history. The original program was written in 1976 as a set of macros for an existing text editor called TECO. Emacs originally was an acronym for Editor MACroS, unifying the many TECO command sets and key bindings. TECO is both a character-oriented text editor and an interpreted programming language for text manipulation. Emacs has come a long way since 1976. It offers a robust Lisp interpreter that is hugely extensible and hackable. It brought to light lots of novel concepts such as an infinite clipboard, tree-based exploration of history, a reverse variable search, structural editing of code, and recursive editing that let you stop what you are doing, perform other edits, and then revert back to the original task. Emacs is an incremental programming environment, a mutable environment that provides functionality without applications.

  • Michael Kerrisk (manpages): man-pages-5.08 is released

    I've released man-pages-5.08. The release tarball is available on The browsable online pages can be found on The Git repository for man-pages is available on This release resulted from patches, bug reports, reviews, and comments from more than 30 contributors. The release includes more than 190 commits that change around 340 pages.

  • QGIS has chosen Kiwi TCMS

    We are happy to announce that QGIS has chosen Kiwi TCMS for the basis of their Quality Assurance methodology and infrastructure improvement program! Kiwi TCMS will play a central role in storing test case definitions, organizing test cycles, and assigning and tracking test executions by testers from the QGIS community.

Linux Kernel: GPU Blobs, 5.8, 5.9 and ARM32 in Action

  • Netgpu and the hazards of proprietary kernel modules

    On its face, the netgpu patch set appears to add a useful feature: the ability to copy network data directly between a network adapter and a GPU without moving it through the host CPU. This patch set has quickly become an example of how not to get work into the kernel, though; it has no chance of being merged in anything like its current form and has created a backlash designed to keep modules like it from ever working in mainline kernels. It all comes down to one fundamental mistake: basing kernel work on a proprietary kernel module. The use case for netgpu appears to be machine-learning applications that consume large amounts of data. The processing of this data is offloaded to a GPU for performance reasons. That GPU must be fed a stream of data, though, that comes from elsewhere on the network; this data follows the usual path of first being read into main memory, then written out to the GPU. The extra copy hurts, as does the memory-bus traffic and the CPU time needed to manage this data movement. This overhead could be significantly reduced if the network adapter were to write the data directly into the GPU's memory, which is accessible via the PCI bus. A suitably capable network adapter could place packet data in GPU memory while writing packet headers to normal host memory; that allows the kernel's network stack to do the protocol processing as usual. The netgpu patch exists to support this mode of operation, seemingly yielding improved performance at the cost of losing some functionality; anything that requires looking at the packet payload is going to be hard to support if that data is routed directly to GPU memory.

  • Some statistics from the 5.8 kernel cycle

    Linus Torvalds released the 5.8 kernel on August 2, concluding another nine-week development cycle. By the time the work was done, 16,306 non-merge changesets had been pulled into the mainline repository for this release. That happens to be a record, beating the previous record holder (4.9, released in December 2016) by 92 changesets. It was, in other words, a busy development cycle. It's time for our traditional look into where that work came from to see what might be learned. A total of 1,991 developers contributed to 5.8, which is another record; 304 of those developers appeared for the first time in this cycle. The community added over 924,000 lines of code and removed around 371,000 for a net growth of over 553,000 lines of code.

  • FUSE Read/Write Passthrough Updated For Much Better File-System Performance

    Of various criticisms around FUSE for implementing file-systems in user-space, one of the most prolific issues is around the performance generally being much lower than a proper file-system kernel driver. But with the FUSE passthrough functionality that continue to be worked on, there is the potential for much better FUSE file-system performance. The ongoing FUSE passthrough work is about allowing the passthrough read/write of files in avoiding at times unnecessary overhead of the user-space FUSE daemon. When operating in FUSE_PASSTHROUGH mode, the daemon can allow on a per-file basis opening in passthrough mode where all read and write operations are forwarded by the kernel directly to the lower file-system rather than to the FUSE daemon running in user-space.

  • Navi 2 Fixes, Other Graphics/Display Fixes Sent In For Linux 5.9

    Following all of the feature updates to the open-source GPU/DRM drivers for Linux 5.9 that included a lot of new material, the first batch of fixes have now been sent in for mainline in addressing early fallout from these many changes. Ahead of the Linux 5.9-rc1 release this weekend, an initial batch of Direct Rendering Manager fixes were sent out on Thursday.

  • How the ARM32 Linux kernel decompresses

    This is intended as a comprehensive rundown of how the Linux kernel self-decompresses on ARM 32-bit legacy systems. All machines under arch/arm/* uses this method if they are booted using a compressed kernel, and most of them are using compressed kernels.

  • Walleij: How the ARM32 Linux kernel decompresses

    For those who are into the details: here is a step-by-step guide through the process of decompressing an Arm kernel and getting ready to boot from Linus Walleij.

The Linux-based PinePhone is the most interesting smartphone I've tried in years

Android's potential for customization was seemingly endless when it was first introduced, thanks to its Linux kernel and open-source nature. However, Google has introduced more restrictions over the past few years in the name of privacy and security, making root and other deep modifications difficult or impossible. While I agree that most of the security changes in Android are needed (I really don't need the Facebook app digging through my local files), they do mean you are not in full control of your own device. There's still the option of using custom ROMs like LineageOS and Paranoid Android, but they're still limited by the restrictions of Android. Porting ROMs to new phones is a time-consuming and difficult process, they sometimes lack features compared to the stock software (like full camera quality), and some devices don't allow unlocking the bootloader at all. Thankfully, there's now an alternative to Android for enthusiasts who want full control over their phone: the PinePhone, a budget device developed by Pine64 and supported by the Linux community. Despite its many (many, many) limitations, the PinePhone is still the most interesting phone I've used in years. Read more

tdoay's howtos