The "Eternal Software Initiative" is built on “a modification of the Subleq OISC” and supports a port of Linux. #small-is-beautiful #bootstrappable
on 02026-09-03tiny self-hosted #Lisp in #asm (?) #toread for #bootstrappable #small-is-beautiful
on 02026-09-03lrc.dartmouth.edu, low-resource computing conference. #small-is-beautiful
on 02026-08-19endoh1 #IOCCC entry is shaped like a Nixie tube. #C #small-is-beautiful
on 02026-07-30#Rain1’s "Tarot" #Scheme compiler is a Scheme compiler written in 1907 lines of Scheme, which (when compiled) runs on top of a virtual machine implemented in 2033 lines of C, can compile itself, and can be run from plain sources on the Tinyscheme interpreter in about 10 minutes. #small-is-beautiful #bootstrapping
on 02026-07-30Turbo #Pascal 3.01a for #MS-DOS in #emulation. 276K. #retrocomputing #small-is-beautiful
on 02026-06-102-pixel high proportional font, sort of readable if you insert leading between lines. #small-is-beautiful #fonts
on 02026-05-266×6 font with only 5×5 data, along with smaller variants. #fonts #small-is-beautiful
on 02026-04-22#bzip2 #compression #algorithms can be implemented in a few kilobytes of code, handy for the ComputerCraft mod for #Minecraft. #small-is-beautiful
on 02026-03-12#K1ngPrawn's IRC client written in #bash with <>/dev/tcp/$SERVER/$PORT instead of netcat. #small-is-beautiful #Unix
my IRC client written in #bash with #netcat. #small-is-beautiful #Unix
on 02026-03-03Russ Cox on #Mastodon about simple and fast #floating-point printing and parsing in #Golang #toread #small-is-beautiful
on 02026-01-25#small-is-beautiful #automatic-differentiation library in Python for #neural-networks. “Easily extensible autograd implemented python with pytorch API. Uses numpy to do the heavy-lifting. Implementation is very similar to pytorch (graph-based reverse-mode autodiff).”
on 02026-01-04a tiny #SSH server, 42K static stripped. “All AI slop.” Supports “ChaCha20-Poly1305 or Curve25519-donna. Single key exchange: Curve25519. Single host key type: Ed25519. Password authentication only (no public key auth). No compression. No algorithm negotiation (single fixed suite).” Lots of tips for building smaller binaries. #small-is-beautiful #crypto #security
on 02025-11-26#fractals in #PostScript. #small-is-beautiful #graphics
on 02025-11-26#Bel #metacircular #Lisp interpreter spec by #PG. #small-is-beautiful
on 02025-11-05#small-is-beautiful #GUI library #LVGL: “LittlevGL is a free and open-source graphics library providing everything you need to create embedded GUI with easy-to-use graphical elements, beautiful visual effects and low memory footprint”. By “low” they mean like 64KiB.
on 02025-11-05#small-is-beautiful #GUI library #LVGL supports the #glTF file format for #3D-models. #file-format
on 02025-11-05#demo #video of #bootOS by Oscar #Toledo G., demonstrating entering a hello-world program byte by byte, running it, and deleting it. Also demos cubicDoom. #small-is-beautiful
on 02025-10-15#Vi-Hart did fifty #Fizzbuzz programs. “One of the many things I learned from Evelyn Eastmond in my time working with her is this technique for deeply exploring, releasing yourself from preconceptions, thinking in new ways.
You make 50 of something. In one big marathon.” #toread #small-is-beautiful #50-things
on 02025-10-10"Compy" is “A console-based Lua-programmable computer for children based on löve2d framework. (...) Command-line based UI, Full control over each pixel of the display, Ability to easily reset to initial state, Impossible to damage with non-violent interaction” #small-is-beautiful #Lua
on 02025-10-05Jecel Assumpção is working on some #small-is-beautiful languages
on 02025-07-20"XD Pascal": 10kloc #Pascal compiler, “[Golang]-style methods and interfaces”, 2-clause BSD license, but without OO or separate compilation. #small-is-beautiful #compilers
on 02025-06-17#antirez’s 1kloc text editor. #small-is-beautiful
on 02025-05-21Auditable & minimal #JS implementation of Salsa20, ChaCha, Poly1305 & AES-SIV #small-is-beautiful #cryptography #NaCl
on 02025-03-16an older #garbage-collection #tutorial in 100 lines of C. #small-is-beautiful
on 02024-11-22a #garbage-collection #tutorial #small-is-beautiful
on 02024-11-22a #Forth in 512 bytes. Lots of syntax-highlighted #asm, I think the full literate program. By @meithecatte. #toread #small-is-beautiful
on 02024-11-03"Ilo" is a simple MISC stack machine with an environment called "Konilo" built on top of it. This implementation is 150 lines of C. 65,536 32-bit cells of memory, no bytes, keyboard input, serial display, Forth-like block storage of 1024 cells per block, 30 instructions. There’s an implementation of it on PJRC’s 1MiB-RAM #Teensy 4.1 devboard. #virtual-machines #Forth #small-is-beautiful
on 02024-09-10Trygve Reenskaug, at 90 years old, decided to quit #Smalltalk in #Squeak 5.3 in 02020 because “The Squeak programs I have written over the past 20 years are effectively lost because I can’t port them to a current version of Squeak.” Vanessa Freudenberg agrees, “Having worked with a beautifully tiny system like Smalltalk-78, or even early versions of Squeak, the complexity in modern Squeak is staggering. / Smalltalk used to be a system that can be fully understood by a single person - truly a personal computing system. That is no longer the case. / All the functionality we added over the years comes at the price of complexity (not to mention speed). It makes the system hard to understand. It makes it hard to see the design principles. We have not found a way to eliminate, or at least hide, any of the complexity we introduced. / I don't think there is a “solution” for this within the current system. We have accepted the complexity, and now we have to live with it. And we have to accept that that alienates people who are looking for simplicity and elegance.” #small-is-beautiful
on 02024-09-07a macro assembler written in #sh. #small-is-beautiful #asm
on 02024-08-31#small-is-beautiful #Lisp in 223 lines of #asm and 436 bytes
on 02024-08-03A lost #video of the 128-byte #3D #graphics #raytracer called #Spongy. #small-is-beautiful
on 02024-04-15TBC’s "Spongy" by mentor, a #3D #graphics #raytracer of a Menger sponge (#fractals) in a 128-byte (#small-is-beautiful) MS-DOS executable (b013 cd10 6800 a007 bac8 03ee 42ee eeee 4075 f5f7 e340 01f8 f774 15b9 7f00 29ca 60b1 04be f8ff df44 fade 74f8 d9fb de08 80f3 02d9 c9de 0875 04d9 e089 04de c1ad 8b00 df18 e2dd b101 31ed bef8 ffad f7e3 0344 f5f7 e105 ab2a 3d55 5583 dd00 7b0e 83fe fe7c e86b c903 84c9 79dc eb05 fec3 75d4 4b93 c1e8 02aa 6147 7597 452f eb93) winning 1st place in the PC 256-byte division at Function 2009
on 02024-04-15discussion of the BBC #BASIC #3D #raytracer #small-is-beautiful #graphics
on 02024-04-15Explanation and movie of the #3D #graphics #raytracer in 10 lines of #BASIC (in the family of the BBC BASIC one, but for an Atari). #small-is-beautiful
on 02024-04-15Oscar Toledo G. just released a boot sector real-time animated ray tracer, based on the BBC BASIC one, which can be run from a floppy disc boot sector with no OS #small-is-beautiful #3D #graphics #raytracer #asm
on 02024-04-15using Rust to make a 151-byte static amd64 Linux executable in 02015. #small-is-beautiful
on 02024-03-05using #Rust to make a 137-byte static amd64 Linux executable. #small-is-beautiful
on 02024-03-05how to minimize #Rust binary size. #small-is-beautiful
on 02024-03-05Steve Klabnik says, “The smallest ELF executable for x86_64 rustc has produced is 138 bytes.” #Rust #small-is-beautiful
on 02024-03-05“The simplest, fastest repository for training/finetuning medium-sized GPTs. It is a rewrite of minGPT that prioritizes teeth over education. Still under active development, but currently the file train.py reproduces GPT-2 (124M) on OpenWebText, running on a single 8XA100 40GB node in about 4 days of training. The code itself is plain and readable: train.py is a ~300-line boilerplate training loop and model.py a ~300-line GPT model definition, which can optionally load the GPT-2 weights from OpenAI. That's it.” #Karpathy #neural-networks #small-is-beautiful (but it still relies on PyTorch)
on 02024-03-01a bunch of #SuperCollider #music in 140 characters or less. #small-is-beautiful #CC BY-NC-SA
on 02024-02-06A note from 02022 on the #Monome: “Scarcity and Precarity in Small Manufacturing”: “To lead with an actual case: we have not been able to get the STM32 microcontroller used in the Crow (and Grid) for well over two years now, and all estimates are “unknown” (the words from various sales reps I’ve spoken to, ie those at Mouser). Since we’ve sold out and also exhausted our backup-repair-stock, if someone contacts us with a hardware-related break-- for example, somehow the STM32 is fried-- there’s basically nothing we can do (that was previously standard procedure). (...) previously the parts would just go to e-waste since new components were widely available and irrationally cheap.
We are no longer in that era. So I’d like to instill this message, as strongly as possible: your machines are not easily repairable. They may be incredibly difficult (interpret: expensive) or impossible to repair. Please let this inform your treatment and expectations of the machines in your life.” #small-is-beautiful #collapse #hardware #manufacturing #shortages #WWIII #uxn
on 02024-02-06a collection of #MML #music, with 5350 songs, lots of them popular (Michael Jackson, Offspring, Linkin Park, Bryan Adams, Leonard Cohen) or videogame (Zelda, Silent Hill); typically a minute of kind of robotic-sounding polyphonic music is under 1K. #small-is-beautiful
on 02024-02-06BBC #BASIC #graphics #raytracer in half a kilobyte, though I think the line numbers are maybe missing #small-is-beautiful
on 02024-01-17"MicroUI" is a 1.1kloc #IMGUI library in C by rxi, with no dynamic allocation. This version is hacked to run on SDL. It maintains a queue of up to 4096 drawing commands from the library to the app of four types, MU_COMMAND_{TEXT,RECT,ICON,CLIP}, or sometimes maybe JUMP? #small-is-beautiful #noalloc
Vidar Hokstad’s implementation of #TrueType in only 600 lines of Ruby. #small-is-beautiful
on 02024-01-13#DRMacIver’s #Hypothesis subset implementation in under 1000 lines of Python, intended as a tutorial for applying his innovative test-case generation and reduction approach to new languages that aren’t Python. #small-is-beautiful #PBT
on 02023-12-06a #small-is-beautiful non-cryptographic #PRNG called "PCG32" by M.E. O'Neill, in 9 lines of #C. #algorithms
on 02023-12-06Darius’s #PEG parser example compiler for assignment statements with infix expressions to a notional assembly language in 32 lines of code using Parson. #small-is-beautiful
on 02023-10-22#SDF #raytracer in #Haskell #3D #graphics #small-is-beautiful
on 02023-10-08My very first #raytracer (in four pages of C) #3D #graphics #small-is-beautiful
on 02023-10-08#pointcloud #3D #graphics #algorithms with a tiny #ASCII-art implementation in a few lines of C. #small-is-beautiful
on 02023-09-19A #C compiler in 500 lines of Python, targeting #wasm, whose breaks made implementing for “extremely cursed”. Implements arithmetic, precedence, int, short, char, string constants, pointers, simple arrays, functions, and typedefs, but not structs, the preprocessor, or casts. #small-is-beautiful #compilers
#Nayuki’s #FLAC #audio #codec implementation in 200loc for the encoder and 300loc for the decoder, in Java and Python. #small-is-beautiful #DSP
on 02023-08-09more on tiny ELF files; apparently 80 bytes is the minimum for 64-bit Linux. #small-is-beautiful
on 02023-07-09another tiny ELF program, this one for 64-bit Linux. #small-is-beautiful
on 02023-07-09Graeme Smecher’s "Minimax" #RISC-V implementation is really an RV32C native core which emulates non-compressed RV32I instructions by trapping to millicode, using 116 FFs and 398 CLB LUTs, which is crudely maybe 2000 gates or 8000 transistors, not counting the memory. 16 RV32E registers, 512 bits, are maybe another 4096 transistors, bringing the total to maybe 12000: roughly three times the size of the Intersil 6100 or the 6502, and about a fourth the size of the Cortex-M0. This “compressed-first” or “RVC-first” approach is really interesting to me. #small-is-beautiful #electronics #hardware
on 02023-07-07"QSCM", a smooth blend of Scheme and C (a minimal Lisp that compiles to C) #smallisbeautiful #bootstrapping
on 02022-05-21"SF" is a systems variant of #BF that has “interrupts”, really subroutines. #smallisbeautiful
on 02022-05-21some #bytebeat composition notes, with a final result in 255 bytes with a bassline, melody, and percussion. #music #smallisbeautiful
on 02022-05-21ngn’s free software (AGPLv3) implementation of #K, specifically K6, with built-in documentation. #smallisbeautiful
on 02022-05-21#munificent’s #mapgen business card: generates a roguelike dungeon in 1.3K (32 lines of 36 bytes). #smallisbeautiful
on 02022-05-21a real-mode #FORTH that fits in a 512-byte boot sector #smallisbeautiful
on 02021-06-05#Norvig’s spell-corrector (spell corrector) in Python. #smallisbeautiful
on 02021-05-29the announcement of Chibi #Scheme #smallisbeautiful
on 02021-02-09Crockford’s explanation of the Pratt #top-down-operator-precedence #parsing algorithm; Crockford presents a #JS parser that can parse the JS subset it’s written in, cut down from his JSlint. #algorithms #smallisbeautiful
on 02021-01-21Planckforth is a #smallisbeautiful #bootstrapping #Forth bootstrapped from a handwritten 1KB ELF binary. #source-code
on 02021-01-15"stdg" provides #graphics from shell scripts (or anything else that can do text on stdin and stdout) with a simplified PostScript-like command language — but supporting interactivity! Just 1kloc of #Rust. #smallisbeautiful
on 02020-12-01A 16-bit 8086 (?) #Forth in a 512-byte boot sector. #smallisbeautiful
on 02020-11-12notes on #smallisbeautiful: META-II, Strachey's 250-instruction GPM, etc. #parsing
on 02020-10-11#PDF of Chuck Thacker's "Tiny Computer for Teaching" #hardware design for a 32-bit Harvard RISC computer with 4KiB each of instruction and data RAM, based on the Dirty Genitals Nova, occupying 83 lines of Verilog source (if I counted right) and 200 LUTs and four BRAMs on a Xilinx Virtex-5 #FPGA, getting 60 MIPS. #smallisbeautiful
on 02020-06-23The Project #Oberon book #PDF has a chapter about the #Wirth-RISC #hardware, largely the same as the people.inf.ethz.ch PDFs, but covering the Verilog in detail, and for example describing the floating-point format and logic, the PS/2 mouse protocol and its Verilog implementation on #FPGA, and quadrature decoding. #smallisbeautiful
on 02020-06-23#Wirth’s CPU #hardware "Wirth RISC" explained at some more length. #PDF #smallisbeautiful
on 02020-06-20#Wirth designed a very simple CPU for #Oberon (etc.) he calls just “RISC”, though it's not the Berkeley RISC. So I keep calling it the #Wirth-RISC. #hardware #PDF #smallisbeautiful
on 02020-06-20"Tinywm" is a window manager in 50 lines of C. #smallisbeautiful
on 02018-08-16#3D terrain rendering #algorithms from Novalogic’s 01992 game “Comanche” in 20 lines of #graphics code, using ray-casting in voxel space (?) — a pretty standard #heightfields rendering thing really #smallisbeautiful #voxelspace
on 02017-11-25Archive of “Picol”, Antirez’s #Tcl implementation in 500 lines of C, also at <http://antirez.com/picol/picol.c.txt>. #smallisbeautiful
on 02017-08-22#Ray-tracing with global illumination “using unbiased Monte Carlo path tracing” in 99 lines of C++. #smallisbeautiful #rendering #graphics
on 02017-08-06#smallisbeautiful software for Microsoft Windows without source, with a 1.4MB max.
on 02017-07-13discussion thread on a minimal #PDF file by Brendan Zagaeski. #smallisbeautiful
on 02017-07-11a guy is building 8080 CPU #hardware out of discrete transistors. #smallisbeautiful
on 02017-07-11Ken Boak’s #SIMPL #source-code for the MSP430 #microcontroller; I think this is the 780-byte version. The source is only 811 lines of #asm. #smallisbeautiful
on 02017-07-11"SIMPL", a stripped-down #Forth interpreter, is now running within 780 bytes (on I think the MSP430 #microcontroller). #smallisbeautiful
on 02017-07-11a tiny self-contained Unix-like OS, C-subset compiler, and CPU emulator. #bootstrapping #smallisbeautiful
on 02017-05-09Björn’s table-driven UTF-8 decoder in 10 lines of C, not counting the 384-byte table. #Unicode #algorithms #smallisbeautiful
on 02017-04-26another tiny public-domain #Keccak #SHA-3 #crypto hash in 120 “lines” of C, derived from a Twitter account, #simplesha3 I think. #smallisbeautiful
on 02017-04-18#DJB version of #SHA-3 (#Keccak) as a C Python (2) extension module, called "simplesha3", in 47 lines of C (though several lines, taken from the 9-tweet @tweetfips202, are quite dense and obfuscated.) #crypto #smallisbeautiful
on 02017-03-22#FFT #algorithms for #DSP expressed or explained in BASIC. #smallisbeautiful
on 02017-03-22Another replica of Arthur Whitney’s J or K incunabulum from 1989, the one-page interpreter for the 3B1. #smallisbeautiful #APL
on 02017-03-22The hugi-compo sizecoding competition was a series of #smallisbeautiful contests organized by the #demoscene diskmag Hugi, mostly 1998–2003. These compos had strict specs on what the (MS-DOS) program had to do (like ACM and many ICFP programming contests) but were scored strictly by program size. Problems included data compression, text sorting, video games (Pong, Snake (“Nibbles”), sokoban), virtual machine implementations, a sudoku solver, and a program to retrieve the device descriptor from an attached USB device. In more than half of the 29 compo rounds over the years, the winning program was under 150 bytes.
on 02017-03-22BSD-licensed diff algorithm in Python by sbp and Tony Garnock-Jones, using the Ukkonen-Myers algorithm. Diff and patch are 64 lines of code, including blanks. #smallisbeautiful #algorithms
on 02017-03-22A #smallisbeautiful but high-performance #SAT #solver; the original version in 2003 was 600 lines with “conflict-clause recording, conflict-driven backjumping, VSIDS dynamic variable order,” and a “two-literal watch scheme”, plus “extensions for incremental SAT and for non-clausal constraints over boolean variables”, by Niklas Eén and Niklas Sörensson.
on 02017-03-22The International Obfuscated #C Code Contest listing of all previous entries for all years, with brief explanations of what they do. Some parts are public-domain (entries up to 2011); others are noncommercial use only (the guidelines and rules themselves); others are licensed under some version of CC BY-SA (entries 2012 and later). All entries are under about 2 kibibytes, under 1 kibibyte or 1.5 kibibytes in early years. Generally, to fit within this limit, entrants have to find ridiculously simple ways to do difficult things, as well as micro-optimizing to insane levels. Many of the world’s best programmers (Dan Bernstein, Oscar Toledo, Fabrice Bellard) compete. #smallisbeautiful
on 02017-03-22The #LGP-30, selling for US$47000 in 1956, was one of the first computers designed for a single person; it used a drum memory (with some tracks used as delay lines for its registers) and was bit-serial, with 15 flip-flops, 113 vacuum tubes, and 1450 diodes. Its logic design is fully documented in its hardware manual on Bitsavers. It’s famous as the computer from The Story of Mel. #hardware #history #smallisbeautiful #bootstrapping
on 02017-03-22The Nibbler, by Big Mess O’ Wires, is a #homebrew computer whose 4-bit CPU is built from EPROMs, 74181 ALU chips, and 7400-series register chips. #hardware #smallisbeautiful
on 02017-03-22list of most popular #demoscene demos and intros of 256 bytes or under. #smallisbeautiful
on 02017-03-22#video of the presentation of Digimind’s 256-byte intro “Immediate Railways” at Function 2015 with the audience reaction. An interesting 3-D rendered animation in MS-DOS in 256 bytes: mindboggling. #demoscene #smallisbeautiful
on 02017-03-22#C in 4 functions in like 527 LoC (with a stack bytecode interpreter) #smallisbeautiful #compilers #toread
on 02017-03-11“500 lines or less” #smallisbeautiful #ebook released.
on 02016-11-21"Rhodium liquid carbon", a truly amazing little #graphics demo in #WebGL, or really in GLSL, doing real-time volumetric #ray-tracing of a particle system with depth of field, refraction, and glow all in a couple hundred lines of code. By demoscene artist Virgill. #smallisbeautiful #rendering
on 02016-10-23Jack Eisenmann’s Duo Binary runs on an ATTiny84-20PU #AVR with 128K of SRAM and 2MB of Flash #hardware. Six-bit binary character code, short pulse for 0, long pulse for 1. Has a filesystem browser, text editor, calculator, and number guessing game. #smallisbeautiful
on 02016-10-10#concurrency in #500lines #smallisbeautiful
on 02016-08-11this is the smallest #JS #raytracer, at 959 bytes. Rendering takes under 10 seconds on my netbook. #smallisbeautiful
on 02016-07-12A #Lisp #interpreter in 800 lines of C, sort of. #smallisbeautiful
on 02016-01-08“A basic demo of #automatic-differentiation” #smallisbeautiful
on 02016-01-06Ole Sigmund’s widely-cited “99 line #topology-optimization code written in Matlab” from 1999. Elsewhere there’s an 88-line version that’s a lot faster, but the description refers to this version. #smallisbeautiful
on 02015-12-30Julia Evans wrote a small TCP stack in under 500 lines of Python. #networking #smallisbeautiful
on 02015-12-29C in four functions: a self-interpreting interpreter for a subset of C in 10 pages of code, compiling to a stack-based bytecode. #compilers #smallisbeautiful
on 02015-12-29TinyMOD, a 22 kilobyte #MOD #tracker. #smallisbeautiful
on 02015-11-09McIlroy #smallisbeautiful code for arithmetic on polynomials (or more precisely power series, i.e. there may be an unlimited number of coefficients) in ten lines of #Haskell.
on 02015-11-09different #smallisbeautiful programs from Olivier Poudade and Oscar Toledo.
on 02015-11-06#smallisbeautiful chess in 400 bytes of machine code.
on 02015-11-06#smallisbeautiful code.
on 02015-11-06a pint-sized #Earley #parser #smallisbeautiful
on 02015-09-15an #IRC client (bot) written in a couple pages of #BF. #smallisbeautiful
on 02015-09-07a tiny #C subset #interpreter from 2011 for scripting a #microcontroller or two, in 3500 lines of C, which is interestingly like ONE THIRD the size of mawk, in “a few k of code space”. #smallisbeautiful
on 02015-09-05The BLKC4777 #demo. Apparently won the 1024-bytes-and-under category at Assembly this year? And it’s in #JS? #smallisbeautiful
on 02015-08-16The #CEK machine in 14 lines of #Prolog. #smallisbeautiful
on 02015-08-15“#Levenshtein automata can be simple and fast” and useful for finding potential misspellings (like for a #search-engine, with applications given to #Lucene) in a #trie. #Python with #graphviz: 40 lines of code and good (O(max edit distance) supposedly) worst-case #complexity. #smallisbeautiful #algorithms
on 02015-08-15A #machine-learning #neural-network in 11 lines of #Python. #smallisbeautiful
on 02015-08-05#interpreters for #microcontroller (e.g. #AVR) programming languages, including amforth, which needs only 150 bytes of RAM. #smallisbeautiful
on 02015-08-05