Neatroff is a modern reimplementation of the classical Unix troff tool set. In spite of its compactness (the binary distribution requires approximately two megabytes of disk space) it allows to prepare beautifully typed PDF documents with complex layout. It supports UTF-8 encoding, OTF and TTF fonts and bidirectional output. Neatroff includes reimplementation of all popular troff pre-processors like eqn, tbl, refer and others. The implementation is clean and easy to understand in comparison with the original Unix troff full of one-letter variables and other unpleasant things.

I think neatroff can easily replace LaTeX and the heirloom documentation tools for most of tasks performed by typical "home users".

The following link points the umbrella repository that refers to other subrepositories necessary for building of the tool set. Just follow the instructions in README.

https://github.com/aligrudi/neatroff_make

A nice bachelor thesis in which the author tries to determine rational arguments for leaving some actions undefined or unspecified in the standard C. He also researches how optimizing compilers react on code containing various cases of UB.

https://www.cs.ru.nl/bachelors-theses/2017/Matthias_Vogelaar___4372913___Defining_the_Undefined_in_C.pdf

Today I want to step back from the topics of the community and talk about the blog "Simplifier".

In the blog, the author shares the results of his "garage" experiments, publishing short reports with illustrations. I have been reading Simpifier for a long time and am still impressed with the combination of utmost laconicism of reports, asceticism of design and scale of projects.

Just imagine, this modest person who does not even give his name writes about how he tried to create vacuum electrical tubes: diodes and triodes. He described in detail the process of creating several versions of the tubes and gradually improved their characteristics. He achieved good results in a home workshop with minimum of resources. But, of course, the experimenter did not stop there and created a carbon microphone, a wired telephone from home-made components, a paste for creating conductive glass, solar panels, various types of varnishes and coatings for wood and metal, several tools, paints and substances for everyday use, like glass cleaner. Impressive?

The blog is published on the Neocities free hosting service, it is extremely ascetic: a white index page with blue links pointing to denoscriptions of individual experiments. It seemed to me that the author makes diagrams and illustrations in Paint or a similar simple program for raster graphics. With such simplicity of design, it is impossible to break away from reading the text. Content rules!

https://simplifier.neocities.org

A list of tutorials on oldschool graphic effects and techniques like plasma, flame and raycasting.

https://lodev.org/cgtutor/

The following page is a regularly updated illustrated list of computer games available in OpenBSD. This is one of those sites whose reading gives me aesthetic pleasure.

https://mrsatterly.com/openbsd_games.html

Fbpad is a minimalistic virtual terminal that works with the Linux framebuffer. It supports a kind of tabs associated with one-letter tags, so the terminals can be easily switched back and forth.

After minor modifications and configuration, this program has taken a permanent place among my working tools.

This wonderful program was created by the author of neatroff and neatcc.

https://github.com/aligrudi/fbpad

A nice report about breaking the Moscow internet voting system.

The reaction of the developers was strange: they changed a lot the architecture of the system and kept the protocol in secret (according to the report's updates). Security through obscurity? All the modifications were done a few weeks before the first real elections with the help of this voting system. Looks like it is still not ready for production.

https://members.loria.fr/PGaudry/moscow/

GOT (game of trees) is a version control system designed by Stefan Sperling with simplicity in mind. It uses the GIT storage format and is compatible with this popular VCS.
GOT was made for the needs of the OpenBSD community and follows its style and best practices.

https://gameoftrees.org/

Modern reincarnations of troff like neatroff or Heirloom Documentation Tools are very useful and compact. These tool kits can do the same as any LaTeX distribution but require smaller resources. Unfortunately there aren't much documentation on how troff-like processors can be used to prepare nice-looking documents with good typography. Macro packages are also little bit outdated. The project Utroff tries to resolve the problem and provide good macro packages and preprocessors for everyday use.

http://utroff.org/

There are many ways to learn new programming languages. Chris James offers in his book an approach to learn Go - through writing tests.

https://github.com/quii/learn-go-with-tests

ZStandard is a lossless compression algorithm and its reference implementation available under the BSD license. The algorithm uses the Finite State Entropy (FSE) encoding with a variant of Huffman dictionary-based compression. The compression ratio is comparable to zlib and decompression speed is better than LZO can achieve in existing implementations.

https://facebook.github.io/zstd/

Team 28 at Imperial College London has created a baremetal clone of the StarFox game. They wrote the remake for RaspberryPi using the ARMv6 assembly language. Almost 6000 lines of code include a software 3d rasterizer, math and utility libraries, a sound engine (via DMA) and an input subsystem for NES-compatible gamepads. Visit their github account for more information.

https://github.com/ICTeam28/PiFox

BearSSL is a small footprint SSL/TLS C library released under the MIT license.

https://bearssl.org/

Commodore 64, Sinclair ZX Spectrum and other home computers of the past gave their users unique user experience. They weren't toys, they were real computers with built-in programming environments based on a variant of Basic. You didn't need to look for any additional software to start programming, Basic was flashed inside the ROM chip, so after pressing the power button it was ready for your brave experiments. Moreover, every computer was accompanied by a detailed manual on its internals, memory map, I/O registers, etc. And the manual was observable, you could study it and remember most of the things. Modern computers differ a lot in this sense. Just imagine studying the whole systems programming guide from Intel! Ridiculous!

Some guys dream about old fashioned home computers that can be used today. The following project is a bare metal firmware for RaspberryPi with an interpreter of Basic.

https://www.highcaffeinecontent.com/rpi/

The following repository contains an implementation of a simple raytracer in C++ 17 that renders the scene completely at compile time using constexpr function evaluation.

https://github.com/tcbrindle/raytracer.hpp

Adam Dunkels made many impressive things. One of them is twIP - a really tiny TCP stack that fits in one Twitter message. Of course, it isn't a full featured networking stack, such little piece of code just responds to pings, but pay attention to its size - just 139 characters.

http://dunkels.com/adam/twip.html

Linux works well on plenty of 32 and 64 bit architectures with and even without memory management unit. But, is there any way to run Linux on some 8 bit microcontroller? Actually, it is. Everything you need is enough memory and an emulator for any popular processor architecture supported by Linux.

http://dmitry.gr/index.php?r=05.Projects&proj=07.%20Linux%20on%208bit

Indie developers still make new games for NES. Some of them pick a variant of the 6502 assembly language, other ones write their games in C. Developers of the game "What Remains" decided to use own lisp-style programming language based on Racket Scheme and compiled to assembly.

http://www.dustmop.io/blog/2019/09/10/what-remains-technical-breakdown/

On his YouTube channel Luke Smith talks about various lightweight UNIX tools with suckless philosophy. He also has a number of exciting videos on history, politics and Latin.

https://youtube.com/c/lukesmithxyz

The best way to learn the ARMv8 assembly language is reading of ARMARM (ARM Architecture Reference Manual), but if you have no time and need to master only application-level assembly programming — some short tutorial would be enough. One of them can be found below. This tutorial gives an overview of ARMv8, its instruction set and common code patterns. It also shows how various cryptograpic algorithms can be implemented using the assembly language.

https://modexp.wordpress.com/2018/10/30/arm64-assembly/

For a long time I have been collecting examples of extremely tiny software for embedded applications. The following library written by Adam Dunkels was one of the first citizens of the collection. Protothreads provides a kind of coroutines with very little overhead (2 bytes per "thread"), moreover it doesn't use any architecture-dependent context switching code - all the magic is done using a layer of well-organized macros, generating state machines inside functions.

http://dunkels.com/adam/pt/