# less_retarded_wiki

main page, file list (652), source, commit RSS feed, report abuse, stats, random article, consoomer version

# Less Retarded Software

Less retarded software (LRS) is a specific kind of software aiming to be a truly good technology maximally benefiting and respecting its users, following the philosophy of extreme minimalism (Unix philosophy, suckless, KISS, ...), anarcho pacifism, communism and freedom. The term was invented by drummyfish who also made a wiki for it.

By extension LRS can also stand for less retarded society, a kind of ideal society which we aim to achieve with our technology.

LRS is a set of ideas and kind of a mindset, a philosophy, though it tries to not become a traditional movement or even something akin to a centrally organized group; by anarchist principles it sees following people and groups of people as harmful, it always advocates to only follow ideas and to associate loosely. Therefore it tries to only be a concept that will remain pure, such as for example that of free software, but NOT an organization, such as for example the FSF, which will always become corrupt.

{ Someone who's very familiar with LRS and whom I love deeply recently provided very insightful and valuable words of criticism towards LRS and one of the points was that it should rather be called drummyism, as it really IS a reflection of drummyfish's worldview. And that is very true, but I ask to please not use the term drummyism instead of LRS for one simple reason: I strongly believe ideologies and sets of beliefs should NEVER be named after people because ideas are separate from the people. LRS, as the extended societal philosophy, for example advocates for absolute pacifism, but it is possible that drummyfish himself, despite believing in it, would sometimes be pushed to betray his belief and use violence, as people are imperfect and enough torture can anymore make act against his strongest beliefs. LRS, an ideal model, mustn't be stained by the sins of an imperfect being in whose head it came from. ~drummyfish }

As a symbol of LRS we sometimes use heart (love), the peace symbol (pacifism, nonviolence) and A in circle (anarchism), but these only serve as a universal identifier of the philosophy, not as a flag or anything similar -- as flags are a sign of fascism -- for this the official LRS flag is defined to be a completely transparent square (symbolizing simplicity and lack of any secrets) which has a side length of one billion light years times the busy beaver function of the current 64 bit Unix time -- this is so that the flag cannot practically be manufactured and even scaled down versions will hardly serve the purpose of a flag (only the ideal version of the flag is acceptable, i.e. that which is completely transparent and invisible). The official international LRS day is every day in the year and it always takes precedence over any other cause whose day it is supposed to be (as long as it is aligned with LRS the other cause may be acknowledged too, but only in second or lower place).

{ TODO: official currency? }

But please don't be fooled -- despite occasional joking being part of LRS, it is in indeed a serious effort. It sincerely seeks increasing good in the world, just not by traditional means (which LRS usually identifies as harmful) -- that's why it may seem confusing, weird or satirical. LRS is not a company, it's not a non profit, it's not a political party, people aren't paid for it, there are no bosses, therefore correctness and seriousness gives way to sincerity and humanity. Sometimes a joke has blurry borders, sometimes the author himself can't tell if what he said is a joke or not, sometimes something sounds like a joke simply because it truthfully reflects a ridiculous state of society, sometimes something said as a joke turns out to actually be a good idea.

{ In case the previous paragraph still seemed like joke itself: yes, it IS a serious effort. ~drummyfish }

## Definition

The definition here is not strict but rather fuzzy, it is in a form of ideas, style and common practices that together help us subjectively identify software as less retarded.

Software is less retarded if it adheres, to a high degree (not necessarily fully), to the following principles:

- Being made with a truly selfless goal of maximally helping all living beings who may use the software without any intent of taking advantage of them in any way. This is in alignment with less retarded society.
- Trying to follow the Unix philosophy (do one thing well, use text interfaces, ...).
- Trying to follow the suckless philosophy (configs as source files, distributing in source form, mods as patches, ...).
- Being minimalist (single compilation unit, header-only libraries, no build systems, no OOP languages, simple version numbering, ...), countercomplex, KISS, appropriate technology. Any project has to be solo manageable if that's at all possible.
- Minimizing freedom distance, i.e. trying to offer freedom to as many people as possible. Embracing the DIY mindset.
- Being free software legally but ALSO practically (well commented, not bloated and obscured etc., so as to truly and practically enable the freedoms to study, modify etc.). This may also include other attributes related to freedom, such as decentralization.
- Being free culture, i.e. LRS programs are free as a whole, including art assets, data etc.
- Minimizing dependencies, even those such as standard library or relying on OS concepts such as files or threads, even indirect ones such as build systems and even non-software ones (e.g. avoiding floating point, GPU, 64bit etc.).
- Very portable, hardware non-discriminating, i.e. being written in a portable language, minimizing resource usage (RAM, CPU, ...) and so on.
- Being written in a good, suckless programming language -- which languages are acceptable is debatable, but some of them most likely include C (C89 or C99), comun, Forth, Lisp (mainly Scheme), maybe even Brainfuck, False, Lua, Smalltalk, Pascal etc. On the other hand bloated languages like Python, JavaScript or Rust are absolutely unacceptable.
- Future-proof, self-contained (just compile and run, no unnecessary config files, daemons, database services, ...), finished as much as possible, not controlled by anyone (should follow from other points). This may even include attributes such as physical durability and design that maximizes the devices life.
- Hacking friendly, repairable and inviting to improvements and customization, highly adhering to hacker culture.
- Built on top of other LRS or LRS-friendly technology such as the C99 language, comun, Unix, our own libraries etc.
- Simple permissive licensing (being suckless legally) with great preference of public domain, e.g. with CC0 + patent waivers.
- Elegant by its simple, well thought-through solutions. (This is to be contrasted with modern rapid development.)
- No bullshit such as codes of conduct, furry mascots, tricky licensing conditions, ads, encryption, obfuscation etc.

## Further Philosophy

Here are a few bullet points giving further ideas about what LRS is about, also serving as advice for creating such technology:

- Do one thing well.
- Keep it simple, no bullshit. Less is more, worse is better, small is beautiful. Don't overengineer.
- Use compactness and self containment; for example program's source code is at the same time the program's documentation, website's source code may contain code used to generate it etc.
- Users are programmers. This means users can fiddle with their programs; instead of going to request a feature from the developer, the user can many times implement it himself thanks to simple design of the program, EVEN if the user is not an actual programmer (anyone can ctrl+F keywords and rewrite values in source code).
- Bug reports are patches.
- Customization is forking. A software tool is customized by applying personally selected patches and making personal changes to the source code (configuration is also part of source code) -- this creates a personal fork of the tool.
- Forking is good.
- Users compile their programs. Compilation is trivial and fast.
- Programs are distributed in source form.
- Be selfless, program's goal is only to help its user.
- Programs are efficient and take long time to make, they aren't consumerist products, they can't be made on schedule but they should aim to be finished.
- No one owns programs, no one owns data, no one owns art, no one owns information and ideas. Everything is free, legally AND in any other ways.
- Use universal interfaces (text), be compatible.
- No capitalist style usercentrism: a user is NOT above programmer or any other living being (as it is in capitalism). This means that if e.g. a feature can make user's life 1% better but will enslave additional 10 programmers with perpetual maintenance, it should NOT be added.
- No moral/ethical/political thinking done for the user. The user decides what he wants to do, the tool will help as best as it can in whatever the user wants to do, even if the tool's author would disapprove of it. That means no anti-cheating, no DRM, no censorship, no artificial limiting or crippling of the tool.
- Code is reusable.
- Hacking is good. Allow hacking, allow breaking and raping your program in ways you didn't intend, do not artificially prevent anything.
- Be portable, respect weaker platforms and platforms of other types.
- Programs are technology (NOT brands, identities, waifus, franchises, weapons, political grounds, social networks, work opportunities, property, platforms, ...). Technology is art.
- Work is shit, laziness is good.
- Secrets are bad, encryption is stupid, privacy is bullshit.
- Low level is good, use only minimum necessary abstraction.
- ...

## Why

LRS exists for a number of reasons, one of the main ones is simply a need of better technology -- not better as in "with more features" but better in terms of design, purpose and ethics, better as in "better helping the people". Technology has to make us more free, not enslave us. Technology has to be a tool that serves us, not a device for our abuse. We believe mainstream technology poses a serious, even existential threat to our civilization. We don't think we can prevent collapse or a dystopian scenario on our own, or even if these can be prevented at all, but we can help nudge the technology in a better direction, we can inspire others and perhaps make the future a little brighter, even if it's destined to be dark. Even if future seems hopeless, what better can we do than try our best to make it not so?

There are other reason for LRS as well, for example it can be very satisfying and can bring back joy of programming that's been lost in the modern toxic environment of the capitalist mainstream. Minimalist programming is pleasant on its own, and in many things we do we can really achieve something great because not many people are exploring this way of technology. For example there are nowadays very few programs or nice artworks that are completely public domain, which is pretty sad, but it's also an opportunity: you can be the first human to create a completely public domain software of certain kind. Software of all kind has already been written, but you can be the first one who creates a truly good version of such software so that it can e.g. be run on embedded devices. If you create something good that's public domain, you may even make some capitalist go out of business or at least lose a lot of money if he's been offering the same thing for money. You free people. That's a pretty nice feeling and makes you actually live a good life.

{ Here and there I get a nice email from someone who likes something I've created, someone who just needed a simple thing and found that I've made it, that alone is worth the effort I think. ~drummyfish. }

## Specific Software

see also LRS projects needed

The "official" LRS programs and libraries have so far been solely developed by drummyfish, the "founder" of LRS. These include:

- Anarch: Game similar to Doom.
- comun: LRS programming language.
- raycastlib: Advanced 2D raycasting rendering library.
- SAF: Tiny library for small portable games.
- small3dlib: Simple software rasterizer for 3D rendering.
- smallchesslib: Simple chess library and engine (AI).
- microtd: Simple tower defense game written with SAF.
- tinyphysicsengine: Very simple 3D physics engine.
- smaller projects like dumbchat and shitpress

NOTE: Please keep in mind these official projects are not nearly perfect because they're still written with existing imperfect programming languages, using existing (shitty) technology, they're made by imperfect humans and perfection cannot ever be achieved anyway; even LRS itself will evolve and change opinions about details of how software should be written, there is always room for interpretation. For these reason see the projects above not as an example of what perfect LRS software looks like but as an attempt at coming close to it given current circumstances.

Apart from this software a lot of other software developed by other people and groups can be considered LRS, at least to a high degree (there is usually some minor inferiority e.g. in licensing). Especially suckless software mostly fits the LRS criteria. The following programs and libraries can be considered LRS at least to some degree:

- brainfuck: Exceptionally simple programming language.
- dwm: Official suckless window manager.
- Collapse OS and Dusk OS: Extremely minimalist operating systems.
- Fairy-Max chess engine: Tiny chess engine, under 1000 LOC.
- LIL: Tiny embeddable scripting programming language.
- Lisp (mainly Scheme): Programming language with a pretty elegant design.
- st: Official suckless terminal emulator.
- badwolf: Very small yet very usable web browser.
- netsurf: Nice minimalist web browser.
- Forth: Minimalist programming language, one of the best examples of good design.
- surf: Official suckless web browser.
- tcc: Small C compiler (alternative to gcc).
- musl: Tiny C standard library (alternative to glibc).
- FALSE: Super small programming language.
- vim (kind of): TUI text/programming editor. Vim is actually relatively big but there are smaller builds, flavors and alternatives.
- Simon Tatham's portable puzzle collection: Very portable collection of puzzle games.
- ...

Other potentially LRS software to check out may include TinyGL, bootleg3d, scc, t3x, subc, cwm, ed, chibicc, IBNIZ, dietlibc, lynx, links, tcl, uClibc, miniz, Lua, nuklear, dmenu, mujs, sbase, sic, tabbed, svkbd, got, busybox, toybox, darcs, raylib, IRC, Freedoom (with chocolate/crispy engine), PortableGL, 3dmr, openbsd, netrik, mtpaint, uxn (SJW warning), libmsvg and others.

Another idea: search for very old versions of "modern" FOSS software, from the times before things like CMake, Python and QT got popular (or even existed) -- many such projects got bloated with time, but their earlier versions may have been more aligned with LRS. You can get the old source code, it's present either in the git, on the project's website, on Internet Archive etc., compiling it should probably be much easier than compiling the "modern" version. This won't help with things like web browsers (as it won't understand the new formats and protocols), but will be fine text editors, drawing programs, 3D editors, games etc. You can also fork the old version and make it a little better, customize it or publicly turn it into a new program, helping the whole world. See also: unfuck.

It is also possible to talk about LRS data formats, protocols, standards, designs and concepts as such etc. These might include:

- ASCII: Text encoding.
- fixed point: Fractional number format, as opposed to floating point.
- RGB332, RGB565: Simple RGB formats/palettes.
- bytebeat: Simple and powerful procedural music technique.
- farbfeld: Suckless image format, even simpler than PPM, quite beautiful and ingenious in design (in raw form meant for processing with Unix tools, compression is left to specialized compression programs, can beat even PNG).
- flatfile: Using files instead of database.
- rock carved binary data: Way of recording binary data for ages by manually carving them into rock, plastic or similar durable material.
- gopher: Simple alternative to the Web.
- json: Simple data text format.
- lambda calculus: Minimal functional language.
- markdown: Very simple document format.
- PPM: Simple image format.
- qoi: Lossless compression image format in < 1000 LOC, practically as good as png.
- reverse polish notation as opposed to traditional expression notation with brackets, operator precedence and other bloat.
- set theory: Basis of all mathematics.
- textboards, imageboards and pure HTML personal websites as opposed to forums (no registration, no users, simple interface) or even social networks
- Turing machine: Minimal definition of a computer.
- txt2tags: Very simple document format.
- ...

Other technology than software may also be aligned with LRS principles, e.g.:

- simple and cheap bicycle without changing gears, as opposed to e.g. a car
- sundial, hourglass, ...
- old technology such as toys, alert and cars (e.g. the 1980s toy "See n' Say") used to play back prerecorded sounds without using any electronics or requiring batteries, using only a plastic disc that span on needle (in the same way vinyl records work)
- knives are pretty less retarded
- rocks
- tangram, chess, go, backgammon, ...
- simple flute or a home-made drum kit as musical instruments (as opposed to e.g. grand piano)
- street football as a cheap, simple and accessible sport (unlike for example ice hockey)
- less retarded hardware
- ...

## Politics/Culture And Society

See also less retarded society and FAQ.

LRS is connected to a pretty specific political beliefs, but it's not a requirement to share those beliefs to create LRS or be part of the community centered around LRS technology. We just think that it doesn't make logical sense to support LRS and not the politics that justifies it and from which it is derived, but it's up to you to verify this.

With that said, the politics behind LRS is an idealist anarcho pacifist communism, but NOT pseudoleftism (i.e. we do not support political correctness, COCs, cancel culture, Marxism-Leninism etc.). In our views, goals and means we are similar e.g. to the Venus project, even though we may not agree completely on all points. We are not officially associated with any other project or community. We love all living beings (not just people), even those who cause us pain or hate us, we believe love is the only way towards a good society -- in this we follow similar philosophy of nonviolence that was preached by Jesus but without necessarily being religious, we simply think it is the only correct way of a mature society to behave nonviolently and lovingly towards everyone. We do NOT have any leaders or heroes; people are imperfect and giving some more power, louder voices or greater influence creates hierarchy and goes against anarchism, therefore we only follow ideas. We aim for true social (not necessarily physical) equality of everyone, our technology helps everyone equally. We reject competition as a basis of society and anti-equality means such as violence, fights, bullying (cancelling etc.), censorship (political correctness etc.), governments and capitalism. We support things such as universal basic income (as long as there exist money which we are however ultimately against), veganism and slow movement. We highly prefer peaceful evolution to revolution as revolutions tend to be violent and have to be fought -- we do not intend to push any ideas by force but rather to convince enough people to a voluntary change.

## See Also

- less retarded society
- tl;dr and FAQ
- suckless
- Venus project
- reactionary software
- KISS
- Buddhism
- Jainism
- bitreich
- freemasonry
- DIY

Powered by nothing. All content available under CC0 1.0 (public domain). Send comments and corrections to drummyfish at disroot dot org.