lmemsm

I have been wanting to find a way to eliminate the need for msys (and Cygwin) from my development environment for several years now. I finally hit a milestone today.

Year's ago, I'd sent a patch in for GNU autotools because it couldn't even bootstrap itself natively on Windows. The response, the developers refused to accept the patch or fix the issue because there was no working shell on Windows beyond the ones that come with Cygwin or msys. That lead me to looking into porting mksh to Windows. However, when I contacted the developers of mksh, they said they weren't interested in a Windows port because they had a private party already working on it. They may have completed the project, but I have never seen it. winbash works on Windows as does an older version of zsh. I even attempted to port msh from FreeBSD to Windows but I realized it didn't have enough capability to run configure scripts. There is a good solution that doesn't require Cygwin or msys bash though and that's busybox-w32.

Using ash and some of the utilities from busybox-w32 along with some utilities from Minix 2, BSD, sbase and some that I wrote from scratch, I was able to put together a POSIX-like environment with all Win32 native programs. I have a patched version of make that lets me use a shell other than Cygwin or msys bash. I'm also using a custom built MinGW compiler based on the last public domain releases of mingwrt and w32api from the original MinGW project. I've been maintaining my own forks of those projects to preserve the public domain status.

Today, I was able to build FOSS programs with standard gnu autotools build systems like libpng and libtiff completely without msys. I'm sure I still have parts to debug in the environment and features I'd like to add. However, I feel very good about the prospects of finally being able to eliminate msys from my system and being able to completely bootstrap my own build environment (compiler and utilities) from source.

Along with gnu make and the ability to run configure scripts produced by gnu autotools, I have also built an older port of BSD make and muon. Both could be used to build software. I have been completely avoiding CMake with any projects I build. My main problem with it is that it's so complicated, you can't even bootstrap build it. You must have a working copy of CMake to build CMake. This is not true of GNU make. You can very easily bootstrap it. Personally, I like to use a combination of gnu make and CDetect. CDetect does a wonderful job of replacing configure and it's more lightweight with less dependencies. I've rewritten builds of some of the libraries and programs I work with to use CDetect and gnu make in place of other options that I've had difficulty porting. I've been able to replace the build scripts for nano, libressl as well as others and even an older version of cdrtools (last fully GPL'd version). My plan is to stick with C or shell based build programs. It feels far too bloated to require several other languages just to successfully build a C program.

I feel like this is an important step in being able to build the applications I use regularly from source. Should anything go wrong or should the upstream sources become obsolete, I am still able to fix bugs, add features, build and maintain the software I regularly work with.

I keep reading that people think a person should not attempt to create a new Linux distribution unless it's truly unique from all the other distributions already out there. I have been searching and searching for a Linux distribution that meets my wish list of what I'd want and I have yet to find it. So, I finally stopped, examined what I really wanted and wrote down exactly what I'm looking for a distribution.

If there is a Linux distribution that makes all the same choices and has the same goals as this, please let me know. I would love to get involved with the project, volunteer and lend my skills to it. If not, am I truly the only one who would prefer these particular choices? If they appeal to you as well, would you be interested in brainstorming Linux distribution creation ideas? You can reach me on Mastodon if you'd like to discuss this further.


Main Goal: A lightweight Linux and musl based distribution.

Aiming for x86 at this point for use on older machines but that may change.
The choices of software are highly influenced by the ease of building packages completely from source. The project should facilitate users' abilities to patch, modify and rebuild every library and program in the distribution from source code if desired.  Will use the Linux LTS kernel.  Actively avoiding systemd, Wayland, pam, elogind, harfbuzz, ffmpeg and some other complicated projects that fail to do just one thing well.  Avoiding heavyweight GUI libraries such as GTK and Qt.  Using LibreSSL instead of OpenSSL or other SSL libraries.  (See earlier post on SSL libraries for reasons for this choice.) Using pkgconf in place of pkg-config which avoids circular dependencies.  Using bsd-gettext in place of GNU gettext.  Using netbsd-curses and pdcurses in place of ncurses.  Using older X11 kdrive in place of X11libre and Wayland.  Using PicoGL in place of Mesa.  The system will use Busybox for mdev, init, ash and other basic functions.  GNU coreutils are replaced by Busybox and supplemented with other utilities to supply enough functionality to build basic applications.  Other utilities include programs from BSD, Minix 2, sbase, etc.  Compiler is GNU gcc/g++ with musl C library.  Tools such as cmake and meson will be replaced with CDetect and GNU and/or BSD make.  Actively avoiding requiring several programming languages just to build one program. I'm using a custom cross-platform build/package management system that's been field tested for over 20 years.  Using lightweight window manager instead of desktop environment.  Preferred GUI/screen libraries include FLTK, SDL, Raylib/Raygui, otk, pdcurses. Should be console/terminal friendly and users should be able to do useful work or batch programs/processes via the console easily.

Majority of programs in the distribution will be cross-platform portable. So, anyone could run the same programs on different operating systems. One could switch to NetBSD or another operating system including Windows or Mac if necessary and to some extent even FreeDOS and have basically the same programs and functionality available. Software will include enough programs to perform various hobbies with the system such as writing, drawing, music creation, programming, etc.  Games for the system are currently focused on lightweight programs that encourage you to think, popular card and dice games, puzzles, etc.

I've been doing some experiments with WSL. I built an older set of the X11 libraries that doesn't require harfbuzz or libxcb as dependencies. I built them using a musl cross-compiler that creates 32 bit binaries for Linux. I built FLTK with it as well. I'm able to run FLTK GUI applications via WSL. So, the X11 libraries built with musl are capable of talking to WSLg.

It's worth noting that WSL2's 64 bit kernel is capable of running 32 bit ELF binaries. So while many Linux distributions are phasing out 32 bit support, WSL provides a useful platform to continue experimenting with it if desired. Another nice point about WSL is that it can avoid the systemd controversy. While it can be made to work with systemd, it can also use a simple init program or start with /bin/sh if necessary.

It wouldn't be hard to build a WSL distribution at this point. It could also be designed to be completely static or include shared libraries as most Linux distros do. So, a custom distribution would be possible and it would not need to be limited to command line only. It also makes a great testing ground for creating a lightweight Linux distribution that could run natively on older hardware.

WSL has really come a long way from only being able to run command line programs to running X11 apps. The incredible thing is you don't need a specific library such as glibc or specially built Wayland or X11 libraries. It works perfectly well with 32 or 64 bit binaries and a custom built set of X11 libraries. It would make a great environment to custom build a personalized distribution in.

I love the concept of PermaComputing especially when it comes to software. Some of the properties it expounds
are accessiblity, compatiblity (able to work across architectures), efficiency, flexibility and resilience (works offline, designed for the long run). Other desirable properites are being able to boostrap and to reproduce builds. More details on permacomputing are available here:
https://permacomputing.net/permacomputing/

I thought it would be nice to have a collection of links to software that might fit the PermaComputing criteria well. Please feel free to contact me via Mastodon or email and suggest any favorite FLOSS that fits PermaComputing principles that I might have missed.


I have a list of lightweight C software at: https://codeberg.org/lmemsm/delightful-c-software

Grumpy Linux is an interesting project that can build a Linux distro from source:
http://tekk.in/grumpy.html

PermaComputing.net's guide to Minimalist Software:
https://permacomputing.net/projects/

Awesome PermaComputing's list of Software Projects:
https://github.com/thisisisa/awesome-permacomputing#software

With the recent resurgence in using and maintaining legacy software with projects like XLibre and gtk2-ng, I started to rethink my own desktop strategy. Did I want to take the easy route and update a lot of legacy gtk2 software? There certainly are enough choices in software that work with gtk. I did build XLibre (on Debian with musl) and gtk2-ng (on Debian with musl and on Windows with original MinGW) from source. I haven't shared the build scripts for XLibre but I did upload some of my build scripts for gtk2-ng in case they may be of use: https://git.devuan.org/lmemsm/bldgtk After the experience, I found myself wanting a more lightweight alternative even more than before. So what would a more lightweight desktop environment look like? Glad you asked.

First, I should note that a lot of people enjoy collecting software that looks similar and going to great lengths to theme and give their computers a specific look. If that's your interest, check out projects like gtk2-ng and their growing themes collection. That just isn't a high priority for me. My personal preference is for something that's lightweight, with source code that's easy to understand and modify and that does one thing well. I prefer substance to flash. Portability is a priority since I want to use these programs at home or at work and not be locked into a particular operating system. I want applications and libraries on my system that can be understood and maintained by one person. That's especially important to me because I don't have a community to back up what I'm doing.

I maintain a comprehensive, curated list of GUI libraries written in C. I've searched for a GUI library that I would like for many years. I even wrote an article called "In Search of a Portable Screen Library" that appeared in the C/C++ Users Journal back in September, 1996. While I've never found that one elusive GUI I liked, I have found several useful options.

FLTK is pretty much the most lightweight, full featured GUI library I could find. It's not C, it's C++, but it has some nice applications that were created with it. It currently has 4 themes. One I helped to get added after a pen pal did a beautiful job creating it. I had to settle for a subset of his modifications to get it accepted, but it's still nice to have another choice. So, for now I'm using FLTK for any programs that require more extensive GUI functionality. I'm trying to resurrect and update legacy FLTK programs like APCStudio for audio editing and postoffice for email. FLTK already has some very helpful settings applications such as alsamixergui and flsynclient. Georg, creator of XFDOS and NanoLinux, took several FLTK programs and brought new life to them and even designed new ones to create a complete desktop. TinyCore Linux also uses FLTK for their desktop. Between these two sources and the apps that were listed at the FLTK site, one can piece together an entire desktop just of FLTK based programs. FLTK works on the major operating systems. However, if it's used with nano-x, it can be ported to Android, embedded systems and handheld devices. Later versions of FLTK have additions made to ease the creation of other backends without needing to rely on nano-x for portability. I've been working for a long time trying to get SDL to function as a viable backend.

However, I don't want to stop there. I've found several useful SDL applications including a SDL based PDF viewer, an ebook reader with text to speech capabilities using flite, a graphics viewer and a graphics slideshow program and font viewers. Another advantage of SDL is that it works on a wide range of systems from Linux and Windows to handheld devices and Android.

You can find a full range of applications for almost any need already written in curses. While it's fast and useful to run applications in console using options like BSDcurses, there is a port of pdcurses that works on top of SDL. So it can run anywhere that SDL does. While it looks like a text user interface instead of a GUI, using it with a SDL backend can make it function more like a standard GUI application. Most curses/ncurses based programs will work with pdcurses as well. I've been trying to update a nice curses based password manager that uses an earlier version of the keepass database format to work with a more up-to-date keepass format.

OpenGL is a great base for games and makes an interesting backend for developing a GUI. SDL and FLTK can integrate with OpenGL. SDL also uses OpenGL as a backend in some cases. Raylib is another very promising library that works on OpenGL. It was designed to make programming in C/C++ easy to learn. It can work with a GUI called RayGUI. Raylib and RayGUI are highly portable and work on a number of platforms. One other library I like that uses an OpenGL backend is otk. It's extremely lightweight (similar to single header projects). It has some very useful GUI controls and some useful example programs were created for it. OpenGL works on a number of platforms but what if you're on a platform where OpenGL drivers are not available? Mesa, the FOSS implementation of OpenGL, is another option. However, it can be a heavyweight library that's difficult if not impossible to build on many non-POSIX operating systems. There are several lighter implementations that tried to offer OpenGL 1.1 compatibility on handheld devices, older computer operating systems and devices that do not have OpenGL or OpenGLES drivers. One very well-known implementation is TinyGL. It provides a subset of OpenGL. It's been forked multiple times and many projects have added missing features. I've collected several patches and added even more missing features to one fork known as PicoGL. PicoGL has multiple backends including Nano-X, X11 and SDL. I've recently experimented with some success in trying to get otk to work with PicoGL and SDL as an alternative to OpenGL with X11 or Win32.

So while these various projects may all present different looks via their user interfaces and may even seem like random choices, I chose these options strategically with portability in mind. They can provide a coherent, unified porting strategy. OpenGL and/or SDL can be used as a base for many of these options providing portability to any of the operating systems that can support OpenGL or SDL. PicoGL can be used as a backend on systems where OpenGL is not an option. These three options run on multiple platforms. If X11, Wayland and Win32 aren't available on a system, they can work with nano-x or in framebuffer. If SDL works on a system, nano-x, pdcurses and PicoGL can work on that system since they all have SDL backends. I'm working on adding FLTK and otk to that list. If OpenGL is available on a system, SDL and Raylib work well with that. If nano-x works on a system such as FreeDOS or an embedded OS, FLTK and PicoGL can be ported using it. The goal is to make these components as portable as possible so they can be used on a wide variety of operating systems. They're also lightweight and fairly easy to build. They can run on more unusual operating systems and be more easily maintained. They may seem like a disparate group of libraries, but I think they could be pulled together and used to build on each other to improve portability and provide a way to run lightweight applications on a wide variety of platforms and operating systems.

I'm aware this type of project isn't going to be something of interest to the average user. It won't appeal to the person who prefers to use a package manager to install applications instantly or to the person who enjoys custom theming and making everything look coordinated on his or her system. I am primarily doing this for myself and will continue to work on these types of projects on my own. However, it would be fun to find others with similar interests to compare notes and possibly brainstorm, find new programs to port or share patches to bring new life to some older applications. Imagine running a set of lightweight applications on a very old laptop or computer or a handheld device. If it runs efficiently on older computers, it will run even faster on modern ones. It also gives one person the opportunity to know how to build and maintain the applications on his/her system. That person isn't stuck waiting for a patch from upstream or worrying about whether a favorite project will be abandoned. So, if anyone is interested in discussing a GUI landscape like this further, feel free to contact me on Mastodon (https://fosstodon.org/@lmemsm) or by email. Let's talk.

It's getting harder and harder to find C/C++ programs. Many developers are working in other languages. Developers should have the choice to work in whatever language they want. However, it's dismaying to see the lack of C/C++ software currently available.

I recently tried to find FLOSS programs to set up a database structure and transfer tables from a working database to a new one. I'm trying to migrate the information from Microsoft SQL to PostgreSQL. While both systems have some great tools, I found it hard to locate easy to install, stable programs that could get the job done.

Microsoft SQL has sqlcmd and bcp. These programs can be used to query data from scripts or dump tables. PostgreSQL has psql and pg_dump. These have similar functions. While one should theoretically be able to use bcp to output a table and psql with the copy command to load a table, actually doing it successfully is another story. Any irregular data causes the transfer to fail. While these tools are really nice for batch scripting, they have limited use in some cases.

I saw recommendations for tools such as pgloader, ingestr, embulk and DBeaver to help me get the job done. It took forever to get pgloader to accept irregular passwords. I finally got a script that sort of worked. It moved 500 table structures over from Microsoft SQL to PostgreSQL. It started moving data and then it hung saying max connections reached. Changing its settings to try to make it use less connections did nothing. Plus, pgloader wiped out any tables and data I had already tried to move previously. Trying to install ingestr and embulk was a nightmare. Even with package manager tools like dnf, I was unable to get them fully installed and working properly. The tools are written in Python and Java. They require tons of support packages. The packages need to be installed using other methods than the local package manager such as by pip. I got absolutely nowhere with these solutions. I was told dbeaver could be used as a tool to copy schemas similar to pgloader. When I tried to get information on generating indexes in PostgreSQL that were equivalent to the ones in Microsoft SQL, I just kept getting errors. So, I found a lot of these heavyweight tools to be useless for my needs. They downloaded a lot of files that took up a great deal of disk space. It was hard to find and cleanly remove all the files they needed.

All I wanted was a simple C program that could do the data transfer and wouldn't need hundreds of files and packages installed. I knew a C program could do the job properly because I already had a transfer program that I'd written using C and ODBC that could copy tables. It was written to work with one row at a time which works great with smaller tables or individual inquiries but it wasn't designed for a large data warehouse with millions of rows per table. I spent a week rewriting my C table transfer program to work in batch mode. The new program is specifically designed to copy a Microsoft SQL table to an equivalent PostgreSQL table as quickly as possible. It does nothing more. It doesn't copy PostgreSQL to Microsoft SQL or handle deltas or translation of data. However, it just works and it works very quickly. It doesn't need a lot of space or memory. I wish there were more tools like these available. They're small, efficient and do one job well.

I now have a collection of ODBC based C tools that have been tested on a variety of systems from Windows to Linux to AIX. They do things such as run a query against a database, transfer rows from a table from one database to another, download rows to CSV or XML and more. For small tables, I can download each row to its own XML file. I can do that for multiple databases. I can then run directory/file a comparison tool to compare XML files and see if rows are different between two databases. It would be fun to share tools like these and eventually create enough lightweight tools that they could replace functionality of some of the more expensive commercial ETL or ELT solutions. Does anyone know of other lightweight FLOSS data transfer tools that do one job well? Do you have a good FLOSS ETL or ELT solution? Let me know over on Mastodon.

I wanted to do something FLOSS related to brighten up people's holidays this year. My initial idea was a countdown to the holidays highlighting different Free, Libre and Open Source software each night. While I may still do that on my Mastodon feed, my initial plans were derailed. I'm in the middle of updating my build scripts and rebuilding some of the FLOSS programs I use from source code with the latest versions of libraries. I thought about sharing build scripts and doing some kind of build from source group meetings but I haven't been able to connect with other source code enthusiasts who enjoy building their software from scratch. I also have not figured out an effective method of sharing build scripts or executables. Feel free to contact me on Mastodon if you have any suggestions related to these ideas: https://fosstodon.org/@lmemsm

One thing I can do for the holiday season is put together a list of astronomy related FLOSS programs. I've built several from source over the years and have particularly been on the lookout for lightweight, low dependency astronomy programs that work well on lower resource and older computers. I'll go through my notes and build scripts and try to post some of them here. I will be adding to this page as I find programs. Also, feel free to contact me and suggest your favorites.

Let's start off with the Astronomy Picture of the Day from NASA. You can also find feeds with these pictures on several social media networks and programs that download and display these pictures. NASA's pictures are in the public domain but some of the APOD pictures are from outside contributors and may have be copyrighted.
https://apod.nasa.gov/apod/

Here are some of the more well-known FLOSS astronomy software. Two of the most well known are stellarium and celestia. They run on a wide variety of platforms and I believe there was even an Android port.
Here are links to the Windows portable apps versions. You can find a link to the original web sites from there:
https://portableapps.com/apps/education/celestia_portable
https://portableapps.com/apps/education/stellarium_portable

There are also addons for celestia but the licenses may vary:
http://www.celestiamotherlode.net/

Other FLOSS astronomy programs I often see mentioned include:
https://kstars.kde.org/
https://www.ap-i.net/skychart/en/start
https://sourceforge.net/projects/openuniverse/
http://www.moshier.net/ssystem.html

Next we have astronomy software for Android. Google's Sky Map program is Open Source. You can find a copy of it and other interesting astronomy programs at F-Droid. There has been a lot of discussion over whether F-Droid will be able to continue its mission with the changes to Google policies for software installation. That's a topic for another post. In the meantime, download these while you can. It wouldn't hurt to have the APKs stored someplace and to look into installing adb (Android Debug Bridge) on your computer for future use just in case.
https://f-droid.org/en/packages/com.google.android.stardroid/
https://f-droid.org/en/packages/org.tengel.planisphere/
https://f-droid.org/en/packages/space.celestia.mobilecelestia/
https://f-droid.org/en/packages/com.forrestguice.suntimeswidget/

Finally, here's my favorite category, lightweight cross-platform portable astronomy software. One program I really like is nightsky. It works anywhere the SDL library does. It's been ported to a wide range of platforms including handheld devices. It's lightweight but it's not limited to the command line. It was written for SDL 1.2.x but I do have a patched version that works with SDL 2.x. Haven't had time to look into updating it for the latest version of SDL yet. The lunar calendar program, lcal, is another lightweight option. It is a command line program and generates a postscript lunar phase calendar.
https://nightsky.sourceforge.net/
https://pcal.sourceforge.net/

Command line program and library to show sunrise and sunset.
https://github.com/troglobit/sun

Some lightweight X windows programs with an astronomy theme include:
https://github.com/memarc/sunclock
https://hewgill.com/xearth/original/
https://sourceforge.net/projects/xplanet/

The starplot 0.95.3 program is an older program that requires GTK+ 2 to build.
https://packages.debian.org/bookworm/starplot
https://www.freshports.org/astro/starplot/

The gstar program is a GTK 1.2 front end for the starchart programs which is also included. The starchart program is a command line program that creates star charts in postscript format.
https://users.wfu.edu/cottrell/gstar/

The hebcal program is a command line calendar program that also gives the time of sunset:
https://sourceforge.net/projects/hebcal/

The astrolog program is a command line astrology program but the code has some useful astronomy calculations. It used to be freeware but is now available as Free Software.
https://www.astrolog.org/astrolog/astfile.htm

The aa program is an astronomical almanac which calculates orbits of planetary bodies and reduces the coordinates of planets or stars to geocentric and topocentric positions. It was recommended by Neville Jackson on the It's Foss Community Discussion board.
https://github.com/pmontrasio/astronomical-almanac-js/blob/master/aa.c

Some other programs I haven't personally tried but look worth checking into are:
https://github.com/dcf21/star-charter
https://github.com/da-luce/astroterm
https://github.com/XEphem/XEphem
https://github.com/nasa-lambda/skyviewer
https://github.com/astromatic
https://siril.org/
https://github.com/OpenSpace
https://github.com/csete/gpredict
https://sourceforge.net/projects/previsat/
https://github.com/pchev/virtualmoon
https://sourceforge.net/projects/virtualplanet/
https://github.com/artyom-beilis/skyhopper
https://github.com/cosmonium/cosmonium
https://github.com/pmontrasio/astronomical-almanac-js
https://sourceforge.net/projects/hnsky/
https://github.com/AndrewBuck/orsa
https://github.com/cosinekitty/astronomy

I've been collecting some FLOSS links to programs that might be of interest to science fiction enthusiasts for a while now. Thought I'd document them in one place.

Here are some FLOSS useful projects for anyone interested in astronomy:
https://nightsky.sourceforge.net/
https://portableapps.com/de/apps/education/stellarium_portable
https://portableapps.com/apps/education/celestia_portable
https://f-droid.org/en/packages/org.tengel.planisphere/
https://f-droid.org/en/packages/com.google.android.stardroid/
https://www.openspaceproject.com/

Here are some science fiction related games:
https://github.com/IceCreamYou/Daleks--JS-web-version-
https://gitlab.com/esr/super-star-trek
https://github.com/jj1bdx/bsdtrek
http://starvoyager.bluesky.me.uk/
https://www.netrek.org/
https://identicalsoftware.com/games/smalltrek
https://scp.indiegames.us/
https://web.archive.org/web/20200129140943/http://www.barnsdle.demon.co.uk/game/starlanes.html

Here are some science fiction related apps:
https://f-droid.org/en/packages/com.example.android.maxpapers/
https://f-droid.org/en/packages/net.ddns.mlsoftlaberge.trycorder/
https://f-droid.org/en/packages/org.tlhInganHol.android.klingonassistant/

There are several projects related to LCARS ( Library Computer Access and Retrieval System ) used by the UFP. Here are some of them:
https://github.com/louh/lcars
https://sourceforge.net/projects/lcars24/
https://sourceforge.net/projects/lcars/
https://sourceforge.net/projects/lcars-system-3/
https://sourceforge.net/projects/lcars-win/
https://sourceforge.net/projects/gtklcars/

Have I missed any of your favorite science fiction themed Free, Libre and Open Source Software? Feel free to recommend some new links: https://fosstodon.org/@lmemsm

Let's talk console based software and FOSS operating systems. First, some console based software resources I've liked over the years include:
https://inconsolation.wordpress.com/
https://termux.dev/en/
https://archiveos.org/rogue/
http://inx.maincontent.net/

I have some other resources and console program recommendations in other articles I've written here.

I've seen a lot of FLOSS projects try to convert Windows users to Free Software by sharing GUI based Free operating systems that look a lot like Windows. I really don't know if this is the best strategy to convert people to using something else. Wouldn't it be nice to offer something better and more intuitive rather than just copy what another system can do? I certainly do not think this a good strategy for getting die-hard Windows command line users to switch to FLOSS operating system alternatives. Users that started on DOS and graduated to Windows should be a great market to tap into. Many Unix and Linux systems emphasize console based interactions. However, when Free Software advocates try to reach Windows users and get them to switch, they often end up showing off Windows-like GUIs. They leave out a portion of the market. They leave out the Windows users who don't use Windows because of its GUI design.

What about those of us who still prefer a good old-fashioned command line and want to use console or terminal sessions to get the majority of work done? What kind of conversion path to a Free OS is there for us?

FreeDOS is a wonderful option if you just want DOS. Unfortunately, a lot of current hardware support and drivers are lacking. For years, I've had trouble switching to Linux due to hardware incompatibilities and driver issues. Of all the FOSS operating systems I've tried (BSD, FreeDOS, Minix, etc.), Linux has the best driver support. So, if Linux can't support someone's hardware, it's very likely other options like FreeDOS can't either. FreeDOS does do a very decent job of supporting legacy software and hardware though.

ReactOS is a great path for people who want to use a Free Operating system but want the familiarity of Windows. It runs many Windows programs natively. You can continue to write programs using a Win32 API and have them work on the system. Like FreeDOS, it also doesn't have the drivers and hardware support a commercial system does. Theoretically, when they have something fully compatible with Windows, Windows drivers should just work. It's not at that point of development yet. The biggest drawback I had when trying to use ReactOS was stability. Some Windows programs worked perfectly out-of-the-box. Some crash. I would have liked to get more involved with the project and possibly debug some of my issues. I didn't find it an easy project to join in on if you wanted to help with development.

Using Linux with Wine is another option for people who want to keep using their Windows programs on a Free operating system. I even read about a ReactOS side project where someone used Linux and Wine as a starting point for a ReactOS like system. I love the idea of being able to compile Win32 programs on Linux natively with winelib and have them work on Linux. However, the usual usage is to run Windows programs (closed source) with Wine which emulates a Windows system. They don't even encourage building programs from source with winelib. Personally, I've always found winelib hard to build from source and Wine hard to install on my systems. Some Linux distributions support working with it better than others and some Linux distributions come with Wine already installed.

The X Windows alternative nano-x also offers some Win32 support so you can compile some Windows programs and use them on a system with nano-x libraries. You can build nano-x like an X Windows alternative with client/server support. Projects like NanoLinux and XFDos have created desktop environments using it. You can also build everything into one application (the client and server support) and run applications without a separate nano-x based desktop environment. Most projects have used nano-x to build X11 applications without requiring X11 libraries. However, the potential to port some Win32 applications using the micro-windows part of nano-x is there. Also, nano-x works with a wide variety of operating systems and on a wide variety of hardware.

There are several options for Linux distributions that try to attract Windows users either with Windows look-alike GUIs or with WINE offering the ability to continue to run real Windows programs. However, what is there that's been designed to appeal to those of us who are command line users and want to make a switch? Other than distributions used for restoration or rescue systems like grml and distributions that target minimal systems such as Linux distributions you can run from a floppy or CD, there really aren't many distributions that emphasize a command line interface. There are even less if you're looking for active distributions. Termux is an exception and it targets Android users.

Shells like bash or ash may offer more functionality than batch files, but what competes with Powershell on Linux? At least Mono offers an alternative to .NET. Also, someone who works with a lot of batch files may not find the switch from batch to a shell script all that easy. Backslashes are replaced by forward slashes. Commands like cp and mv are similar to copy and move but don't quite work the same way. Type copy filename in a command line on Windows or DOS and it copies the file to the current directory. Try that in a bash shell with cp and no target file name and you could end up with a mess. Similar syntax that works on Windows may end up corrupting files on Linux/BSD/Unix. If a user isn't already familiar with bash, ash or some of the other shells used on Linux, it's not an easy switch. Just switching between a csh and bash can be a real nuisance to Linux users. Imagine switching from batch to bash.

FreeDOS used to be able to run embedded with Linux systems much the way Windows used to allow users to switch between Windows and DOS. I don't know if that's still an option with Linux distributions and FreeDOS, but DOSBox can make a useful alternative if you want to run Linux and some form of DOS together. Using FreeDOS or DOSBox with Linux allows people to keep working with batch and already created batch scripts. The one drawback with DOSBox is that it doesn't allow for long filenames (beyond the 8.3 convention). There may be some patches to DOSBox that fix this. If so, I would love to find them.

I like the idea of using JavaScript at a command line. It makes an interesting alternative to a shell script. Windows offers this option as part of its wsh system. However, the JavaScript used by Windows is non-standard. It has several extensions not used by other JavaScript implementations such as commands to work with the file system. I looked into projects like TeaJS that work on both Windows and Linux systems as a scripting option. NodeJS seems to have become the de facto standard for command line JavaScript. Plus, it's a cross-platform solution. The main drawback I've heard regarding NodeJS is that the API changes rapidly. So, it's not a very stable system to create command line scripts that you want to be using for years to come.

What are some FOSS operating system options that might appeal to command line users? One could start with a minimal system like Debian netinst or AntiX or TinyCore Linux or possibly some of the musl based distributions. Distributions with large software repositories may have some useful command line applications. Inconsolation showcases many console based apps available from repositories. However, some applications may be dated, not actively supported or have such limited usage that they aren't easily found in a repository. In those cases, it may require building them from source if someone wants to work with them. So, no particular Linux distribution really stands out to me as the best migration path for console users who want to switch to a FOSS system.

For me, the easiest migration path is to have FLOSS programs that work on multiple operating systems. I can use them on a FLOSS operating system, but I can also use them at work where we are required to use closed and proprietary operating systems. If a cross-platform FLOSS program saves data in a particular format, it's likely to use the same format across multiple operating systems. It makes it easier to work with and transfer data. It also helps when the commands you learn, function the same in multiple environments.

Here are some command line tools I use on multiple platforms. I do a lot of my music creation using abc2midi and abcm2ps. I use TiMidity++ in console mode or via command line to convert midi files to wave files. I use diffh and a web browser to view file differences. lxsplit is nice for splitting and joining large files. I use lynx to check if a web page is browser-friendly and accessible. I use a lot of archive tools, communications tools such as curl and putty's plink and psftp, database connection tools, etc. from the command line. There are calendar programs like lcal, dictionary and grammar programs such as sdcv and diction, timer programs and more. There are even programs to draw or edit graphics such as gle, netpbm, imagemagick and graphicsmagick and programs to create DVDs such as dvdauthor.

There is a pattern I've seen with Linux for a long time now. There are great FLOSS program options that appeal to many types of users including those who prefer the command line. With software, having lots of choices can be a positive. However, with operating systems, choice isn't always so positive. There are so many Linux distributions and FOSS operating system options, it's difficult to find one that's user friendly and a good fit. With Windows, there's just one source for it and programs that work on one Windows system work on another Windows system. With Linux, it's not one size fits all. There are so many alternatives and often, none seem to be just right. It's hard to use software from one Linux distribution in another, let alone try to get your Windows executables to run properly. Maybe if more of the Linux community adopted the Linux from Scratch motto of your operating system, your way, it would be easier to switch. However, with lots of Linux operating systems, each with their own niche and their own emphasis on certain features and distinct avoidance of other features, it makes it hard for a user that doesn't fit a specific demographic to use a particular distribution. It's even harder for someone who wants to volunteer efforts to help out a distribution to find the right distribution that would accept the type of help he or she would like to offer.

FOSS is supposed to give users a way to get off the merry-go-round of continually needing to pay to upgrade hardware and software. However, it's not always easy to make that switch. Just offering an operating system that outwardly looks similar to a Windows solution so it will seem familiar isn't always desirable. It can be harder for users when software seems almost alike but certain parts don't work the same way or may potentially have devastating results. The cp command overwriting files that copy wouldn't is a good example. Offering GUI solutions to attract Windows users who primarily use the command line is just not an effective strategy.

What techniques or features would make the switch from another operating system easier for you? If you're like me and prefer working in a console based environment, what would your ideal operating system look like? Have you found a FLOSS distribution or FLOSS tools that fit well for you? Please feel free to share some of your more useful FLOSS finds with me on Mastodon.

I've been interested in web browser development for a while now. Trying to find a lightweight web browser than can be built independently from source and still supports the ability to view the average modern web page is extremely difficult. I feel like the main browser developers now have so much of a monopoly over web development that they managed to become the web standards committee, taking this job away from the W3C which originally maintained web standards. They control what standards become part of the web and even eliminate the need for certain products. Products like Flash and Silverlight became practically obsolete with the advent of HTML 5. While Flash and Silverlight weren't exactly a boon for Free and Open development, the current web standards are so difficult to develop for that independent commercial and Free/Open development alike are both at a loss to keep up.

Some of the browsers I was able to build myself included Netrider, D+ and lynx. Netrider ( https://sourceforge.net/projects/netrider/ ) is based on an older version of webkit. It has a FLTK front end, but was designed to easily allow for other front end development using other GUI libraries. I've used it with SDL and other options. I also ported it to work on Windows so it provided a cross-platform solution. D+ is an older fork of Dillo. Unlike Dillo it works on a variety of operating systems including FreeDOS. Lynx is a text based browser.

There were several text browsers at one point but now development seems to have stopped. Originally one could surf the web using just a text based browser but trying to do so now, is extremely difficult. Many web pages just don't render well in text alone. This is doubly troubling because it's removed the ability for many to use text based browsers and it's made it more difficult for those who are visually impaired to surf the web. I often used text browsers to make sure that the web pages I created rendered well and were easy to navigate. This was one test I used to ensure the pages were user friendly for the visually impaired and the browsers they often use. Some other older text browser projects include links, links2, elinks, w3m. Links was an interesting project as far as text browsers go because it allowed some viewing of graphics using the Linux framebuffer or SDL.

Fifth ( https://github.com/clbr/fifth ) is also an interesting web browser alternative. It's available as a package for TinyCore Linux. Like Netrider, it's based on an older version of webkit and provides an FLTK front end. Unlike Netrider, it's not as portable to other platforms such as Windows.

I looked at netsurf at one point because it's one of the few active independent web browser projects out there. I was unable to build it myself from scratch. It had several libraries, little documentation on building and I had difficulties finding out which version of which library worked with the others. So, I had no luck getting it to build independently as a cohesive project.

Some suckless.org developers solved the issue of getting a modern day web browser to build from source by adopting surf. Surf uses webkit and a GTK GUI front end. The Linux from Scratch project currently includes lynx, links and these browsers in their documentation: https://www.linuxfromscratch.org/blfs/view/svn/xsoft/graphweb.html

There are several interesting independent browser development projects but like surf, they typically use libraries such as webkit or gecko from a larger web development project.

Some independent operating systems are trying to find a way around the browser issue by developing their own. Ladybird from SerenityOS is an example of this: https://ladybird.org/

Some developers are trying to simplify browser development by creating an alternative to the HMTL 5 standard. This is where Gemini comes in. Unfortunately, Google has renamed their AI to Gemini as well which makes it difficult to search for information on the Gemini protocol. One can read more about Geminispace here: https://geminiprotocol.net/ There was an interesting critique of the Gemini protocol from the developer of curl: https://daniel.haxx.se/blog/2023/05/28/the-gemini-protocol-seen-by-this-http-client-person/ I'm not sure if any of his issues have been addressed but so far, Gemini hasn't hit the mainstream for replacing the World Wide Web and HTML 5. I have to say, I do like the looks of the Gemini based web sites. However, not all Gemini browsers can render all the sites. The protocol is still evolving and some functionality is experimental. So, it seems to share some similar issues with World Wide Web surfing.

The problem of being able to easily build a web browser from source without requiring a huge number of libraries has been around for a while now. It appears that it will continue to be an issue for independent operating systems and lower resource computers for a long time to come. It would be great to find solutions that would make web browser development less of a monopoly only attempted by major players. I'm surprised groups like the Free Software Foundation don't feel this is an area that should be considered for their High Priority Projects. I guess many believe that as long as there are Free, Libre, Open Source browsers out there that provide source code, it shouldn't matter that it requires a large organization just to build them while building from source is out of reach for the average developer. However, my personal philosophy is that one of the key advantages of Open Source is to be able to build and modify the code for yourself. If I'm unable to do that with a project, it loses a lot of its usefulness for me.

Here's a short but in no way all inclusive list of some web browser projects that avoid using major web libraries such as as webkit and gecko:
https://ladybird.org/index.html
https://www.netsurf-browser.org/
https://github.com/CobaltBSD/neosurf
https://dillo.org/
https://sourceforge.net/projects/dplus-browser/
https://github.com/textbrowser/dooble
https://lynx.invisible-island.net/

That's a quick rundown of the state of alternative browser development. If I've missed any other relevant FLOSS browser or Open protocol options, you can reach me on Mastodon and let me know.