Less Retarded Software

This is LRS, software that is less retarded. LRS is closely related to suckless, minimal, KISS and Unix philosophy SW.

There is a whole new LRS Wiki!

LRS attributes

• Following the Unix philosophy, i.e. writing small programs that do a single thing well, that communicate using text etc.
• Being truly free SW and focusing on real and absolute freedom, not just on paper (i.e. having a free license), but also in practice (i.e. being accessible, friendly and inviting to modding, improving and sharing). Each project is ideally written by a single person (to prevent legal doubts) and released completely (not only code but also data) and very clearly to the public domain using CC0 plus a waiver of any other rights (like patents). Other licenses are also acceptable, with preference for more permissive (MIT, ...) to copyleft (GPL, ...), but discoraged.
• Minimizing dependencies and not using what's not very necessarily needed, and that in a wide sense, not only in terms of SW and HW, but also e.g. user's required education level.
  • Preferring to not use libraries, not even the standard library. When it is unavoidable, use a thin interface to abstract the specific library away; e.g. instead of using printf() write an abstract function that calls printf and which will allow to easily replace printf() with another function.
  • Preferring to not use floating point but rather integers interpreted as fixed point numbers (e.g. 1024 meaning 1.0).
  • Preferring to not use file I/O. Configuration and assets can be part of the source code and compiled into the program.
  • Preferring to not use build systems, not even Makefiles. SW should ideally be compilable with a single compiler invocation.
  • Preferring to not use GPUs, other special HW or instructions like MMX.
  • Not using bad/heavyweight/bloated languages like C++, Java or Python and bad paradigms like OOP. Scripting languages like Python are acceprable for "throw away" scripts and small scripts that e.g. comvert between file formats.
  • Not being dependent on or linked to any IDE, OS, VCS, documentation systems etc.
  • Not using COCs and similar legal fascist inventions.
• Focusing on simplicity and accessibility in a wide sense (simple to use, understand, modify, compile, fork, share, port etc.).
  • Writing libraries in a single header file (simple to copy, install, compile, review etc.). Programs should also try to avoid being spread throughout many files, ideally it is written in a single file (this is easier and faster to search, edit, copy, process, compile etc.).
  • Using single compilation unit, no extra linking. This is no problem with small efficient SW, as compilation is extremely fast. If compilation is becoming slow, your project is getting bloated and you should simplify it or split it into multiple projects.
  • Using simple formats and interfaces (like plain ASCII instead of UTF, CSV instead of XML etc.), algorithms, design principles and approximations, unless this is for some reason not possible.
  • Preferring compile-time options and static allocation to dynamic behavior. Dynamic behavior comes at a cost (e.g. having a resizeable window introduces more complexity and costs performance, with fixed-size window the compiler knows the size at compile time and can optimize the code).
  • Commenting, formatting and self documenting the source so that it can be understood from the file alone, without the need to e.g. browse online documentation.
  • Each project should consist of at most 10 KLOC of newly written code.
• Using good languages (and other tools), such as C99 because they offer control, portability, efficiency, compatibility and are very safe from going extinct (a C compiler is and always will be probably the most important piece of software). Other languages like Scheme can also be used. Do not use newest feature creep standards or languages bloated by design.
• Striving to be extremely portable, efficient and not wasting computing resources.
  • Optimizing for the slowest and least powerful supported platform (i.e. preferring bytes to wider types if the SW is to run on 8bit devices).
  • Making effort to run on 8/16/32bit computers with CPUs running on tens of MHz and having only KBs of RAM and storage.
  • Writing thin (easily replaceable) frontends that only serve the absolutely necessary abstraction of platform details, but not going any further.
• Focusing on long-term, trying to be future-proof and safe from extinction. The SW takes into account that technology in a 100 years will be different, dependencies will be lost and computers may even be much less powerful due to technological collapse. The SW is designed with a paranoid mindset to be useful to people in any situation and environment.
• Not motivated by self interest but by collective interest. That is the SW is not made for profit, fame, portfolio etc., it is made to be useful too all people equally. This means the SW will not have restrictions like legal conditions on use, requirement of attribution, ads etc.
• Being hackable, friendly to and encouraging modifications, improvement, creativity and sharing, sincerely.
• Focusing on elegance, beauty and mathematics, that is trying to reduce code size, compress and minimize algorithms and data (as oppose to maximizing features or look).
• Being anarchist, non-commercial, anti-consumerist, anti-capitalist, anti-censorship.

project	abbreviation	status	summary	images
raycastlib	RCL	usable	2D advanced raycasting library for rendering "pseudo 3D" environments, e.g. for games.
small3dlib	S3L	usable	3D software rasterizer, similar to OpenGL but much more simple and portable.
Anarch	SFG	finished	Extremely small and portable game in Doom style.
SmallAbstractFish	SAF	finished	Tiny extremely portable (not only) game library.
smallchesslib	SCL	started	Chess library and engine, including a complete extremely portable game.
tinyphysicsengine	TPE	started	3D rigid body real-time physics library.
		planned	Raycasting library with both low-level functions, allowing implementation of any rendering method based on tracing rays, like raycasting, raytracing, distributed raytracing or path tracing, and high level functions for complete scene rendering.
		planned	BSP renderer, for rendering Doom-like games and environments.
		planned	Library for processing 2D raster images, with many graphics algorithms, format parsers. Would include procedural generation functions.
		planned	Machine learning library (neural nets, evolutional programming, ...).
		idea	General utility library (sorts, searches, strings, UTF, formats, ...).

Page by drummyfish. This page and all its content is released under CC0 1.0 (public domain).