A Statement of Technological Realism

1. Introduction

The modern industrial-technological system demands continuous expansion to survive. This is why the software surrounding us requires more RAM and CPU power every year without offering any real increase in human autonomy or fulfillment. The features remain unchanged from a decade ago, yet the infrastructure has grown massively complex. The technical establishment calls this "progress," but it is actually a mechanism designed to waste physical resources and keep the population dependent on the technical apparatus.

This process is inherently destructive to both human nature and the natural environment. It cannot be reformed; the cycle must be broken.

2. The Failure of Reformism (Suckless)

The "suckless" movement was a form of weak reformism. It attempted to make the technological system more tolerable from within, rather than addressing the core issue of technological complexity. Reform never works; it merely stabilizes the system and prolongs its existence.

3. The Reduction of the Individual

Modern industrial society has stripped the individual of the power process—the ability to conceive, effortfully pursue, and attain the practical necessities of life independently. People have lost the capacity to think logically or produce things for themselves. They have been reduced to passive consumers of technological products.

The market economy of supply and demand does not serve human needs; it creates artificial dependencies to justify its own expansion. Computers are engineered to restrict human imagination to a narrow set of pre-programmed options.

4. The Original Autonomy of UNIX

In the early stages of computing, certain principles recognized that tools must remain within the grasp of the individual mind. The original UNIX philosophy—small utilities performing a single task well, linked by simple pipes—allowed the user to maintain direct control over the mechanism. It was a framework where the individual, not the machine or the corporate hierarchy, retained autonomy.

5. The Growth of Technological Complexity

Because the system cannot stop growing, it abandoned this simple methodology. To integrate every aspect of human life into the technological web, massive, incomprehensible binary structures were created.

Young programmers are forced into this system by economic necessity. They are trained in universities not to think, but to function as specialized cogs in a bureaucratic machine, producing ever larger and more inefficient systems. We now see entire, redundant operating systems deployed inside virtual images just to run basic tasks. This artificial complexity forces society toward a breaking point, accelerating the destruction of wild nature and human freedom.

6. The UXTBd Position

I advocate for a radical reduction in technological complexity and a return to individual self-reliance. Software must be simple, stable, and completely understandable by a single human mind. It must submit entirely to the control of the individual, remain transparent, and consume the absolute minimum of physical energy and resources.

UXTBd Principles

1. Keep It Simple Perfect (KISP)

   A program must execute its singular function completely and without waste. Complex systems inevitably escape human control, generate unforeseen consequences, and create dependency.

2. The Command Line Interface

   Graphical user interfaces are psychological tools designed to treat the user as an incompetent dependent. The command line requires active, logical human thought. Pipes allow individuals to combine tools as they see fit, maintaining autonomy over their workflow without relying on centralized, paternalistic design.

3. Enforcement of the GPLv3

   Permissive licenses (such as the MIT license) are tools of the corporate apparatus. They allow large organizations to seize the labor of individuals, corporate-ize it, and integrate it into the industrial-technological system without reciprocity. The GPLv3 must be used as a defensive shield to deny the system the fruits of independent labor.

4. The User as Programmer

   Software must be written for those who take responsibility for their tools. Code must be direct and readable, avoiding the psychological distance and artificial bloat of high-level abstractions like Object-Oriented Programming. A simple, unpretentious Makefile ensures the individual can replicate and control the build process.

5. Direct Action (Patches over Bug Reports)

   Bureaucracy is a symptom of system control. Bug trackers are useless bureaucratic exercises that offload responsibility. If a tool is broken, the individual must fix it and apply the patch. If you cannot maintain your tools, you are dependent on the system.

6. Finality of Engineering

   A technical problem can be solved definitively. The system's demand for perpetual updates and new versions is an artificial mechanism to ensure continuous economic consumption. Once a tool works, it is finished. New problems demand entirely separate, minimal tools.

7. Language Pragmatism

   Do not pursue the temporary fads of new programming languages manufactured by the technical establishment to solve non-problems. Use whatever tool solves the immediate concrete problem with the least amount of structural complexity.

8. Inevitability of Change

   These principles are not subject to democratic consensus by the dependent masses; they are the logical necessities required to maintain autonomy against a bloated technical order, subject to modification only by UXTBd.