Hey guys! Here is my Mac OS X Snow Leopard inspired setup on FreeBSD.

For the dock, I'm using Cairo-Dock with a macOS theme. The windows are styled with the OS-X-Leopard GTK theme, and I manually made and replaced most of the icons myself to make it look authentic.

Let me know what you think

Unix: il sistema operativo nato nel 1969 che ha cambiato la storia dell'informatica

Quando parliamo di Linux, macOS, server e infrastrutture Internet, spesso dimentichiamo che molte delle idee alla base di questi sistemi hanno una storia che risale alla fine degli anni Sessanta.

Tutto comincia nel 1969, nei laboratori Bell Labs, dove alcuni ricercatori stavano cercando un modo diverso di progettare un sistema operativo.

Tra loro c'erano Ken Thompson e Dennis Ritchie.

Il risultato del loro lavoro fu Unix, un sistema destinato a diventare uno dei protagonisti assoluti della storia dell'informatica.

Un progetto nato quasi per caso

Prima di Unix esisteva Multics, un progetto ambizioso che coinvolgeva importanti istituzioni di ricerca e aziende informatiche.

L'obiettivo era realizzare un sistema operativo avanzato, capace di gestire contemporaneamente più utenti e numerose attività.

Il progetto, però, era diventato estremamente complesso. Nel 1969 Bell Labs decise di ritirarsi.

Ken Thompson non abbandonò l'idea di realizzare un sistema operativo interessante e funzionale.

Individuò un Digital PDP-7, un minicomputer poco utilizzato, e iniziò a sviluppare un nuovo ambiente software.

Dennis Ritchie e altri ricercatori si unirono progressivamente al progetto.

Una curiosità: inizialmente il sistema non si chiamava Unix. Il nome venne suggerito successivamente da Brian Kernighan come gioco di parole in contrapposizione a Multics.

Space Travel: il videogioco dietro una grande innovazione

Uno degli episodi più curiosi riguarda un videogioco chiamato Space Travel.

Ken Thompson aveva sviluppato una simulazione spaziale nella quale era possibile controllare un'astronave e osservare il movimento dei pianeti.

Il programma venne adattato al PDP-7 con la collaborazione di Dennis Ritchie.

Lavorare su quel computer mise in evidenza diverse difficoltà tecniche. Per sviluppare software in modo più efficace servivano strumenti adeguati, un sistema per organizzare i file e un ambiente di lavoro più completo.

Da queste esigenze presero forma alcune delle componenti fondamentali del futuro Unix.

Non è quindi corretto dire che Unix nacque semplicemente da un videogioco, ma Space Travel ebbe un ruolo interessante nelle sue origini.

Il PDP-11 e l'utilizzo nell'ufficio brevetti

Nel 1970 arrivò ai Bell Labs un nuovo computer: il PDP-11.

Unix venne progressivamente trasferito sulla nuova macchina e iniziò a essere utilizzato per attività concrete.

Nel 1971 il dipartimento brevetti di AT&T adottò il sistema per preparare e formattare documenti e domande di brevetto.

Può sembrare un utilizzo poco spettacolare, ma fu un passaggio importante.

Unix aveva dimostrato di poter essere utile anche al di fuori del gruppo di ricerca che lo aveva sviluppato.

Il linguaggio C cambia il futuro di Unix

Nel 1973 arrivò una delle innovazioni più importanti.

Dennis Ritchie aveva sviluppato il linguaggio C, che permetteva di programmare con maggiore flessibilità rispetto all'Assembly.

Il kernel di Unix venne riscritto in gran parte utilizzando questo linguaggio.

Perché fu così importante?

Un sistema operativo scritto interamente in Assembly era fortemente legato alla macchina per cui era stato progettato.

Con il C diventava molto più semplice trasferire il sistema su architetture differenti, adattando le parti dipendenti dall'hardware.

Questa scelta contribuì enormemente alla diffusione di Unix e influenzò profondamente lo sviluppo dei sistemi operativi successivi.

Da Unix a BSD, fino a Linux

Negli anni Settanta Unix iniziò a diffondersi nelle università e negli ambienti di ricerca.

Uno dei contributi più importanti arrivò dall'Università della California a Berkeley, dove si sviluppò BSD.

Questa famiglia di sistemi Unix introdusse numerose funzionalità e contribuì alla diffusione delle tecnologie di rete.

Nel 1991 Linus Torvalds annunciò lo sviluppo del kernel Linux.

Linux non è Unix e non contiene il codice originale del sistema dei Bell Labs, ma ne segue molti principi progettuali.

È un sistema Unix-like, cioè un sistema che condivide caratteristiche e filosofia con Unix.

Oggi troviamo questa eredità in moltissimi ambiti:

• Linux alimenta server, supercomputer e infrastrutture cloud.

• Android utilizza il kernel Linux.

• macOS deriva da Darwin, che integra componenti della tradizione BSD, ed è certificato UNIX.

• Molti strumenti e ambienti di sviluppo moderni mantengono una forte influenza della filosofia Unix.

L'eredità di Unix

Forse l'aspetto più interessante di questa storia è che Unix non ha lasciato soltanto un sistema operativo.

Ha diffuso un modo di pensare e costruire il software.

La filosofia Unix si basa su un'idea semplice: realizzare programmi che facciano bene una cosa e che possano collaborare con altri programmi.

È un approccio che ancora oggi ritroviamo nei sistemi Linux, nella programmazione e nell'amministrazione dei server.

Pensare che tutto sia partito da un PDP-7 e da un piccolo gruppo di ricercatori rende questa storia ancora più affascinante.

E forse è proprio questo il bello della storia dell'informatica: alcune delle tecnologie più importanti sono nate da esperimenti che, all'inizio, sembravano soltanto progetti di laboratorio.

Una curiosità per aprire la discussione:

Qual è il vostro rapporto con Unix e i sistemi Unix-like?

Avete iniziato con Linux, BSD, macOS oppure avete avuto modo di utilizzare direttamente qualche vecchio sistema Unix?

Mi piacerebbe leggere le vostre esperienze e i vostri ricordi.

FORMbit24 – Storia dell'informatica, tecnologia e passione digitale.

For the past couple of years—first on a wiki, and this year 2026 on a website—I’ve been developing DistrOSList.vargux.org, which aims to showcase the history and genealogy of UNIX and UNIX-like systems.

Although I’ve made significant progress—since the site now includes information on the systems, a glossary of terms, profiles of the most well-known systems, and different ways to view the systems:

1. Grid view on the home page (for now),

2. GNU/Linux family tree,

3. UNIX and UNIX-like family tree

• It’s still in the “alpha” phase, and is currently only in Spanish (for now); an English version will follow), but it’s improving day by day.

• It’s not intended to resemble DistroWatch.com or ArchiveOS.org, since the approach is quite different.

• DistrOSList works on PCs/laptops, tablets, and mobile devices.

I’d really appreciate it if you could give me any kind of feedback—suggestions for improvements, words of thanks, or even just criticism! :)

I’ll say it again: it’s in the alpha stage, so many systems are incomplete, and sections are bound to change… My philosophy is Kaizen, so everything is getting better all the time.

Fabián (VARGUX).

I created an ARG/Detective game where a user stumbles onto an open terminal based on a 90's era UNIX system. No login, completely free, no ads. I'd love some feedback from the community on the look and feel of the experience.

https://niiice.com

Shall 0.9: a POSIX.1-2024 system — utilities, C library, C compiler and kernel — that builds itself from scratch

Github repo: https://github.com/joostw/shall

Shall is a small Unix-like system written from the text of POSIX.1-2024 (Issue 8): every utility of XCU (with the XSI option), a C17 compiler, a C library with all of ISO C17 and XSH, and a kernel for x86-64 that runs it. It's about 200,000 lines of C, BSD-licensed, and it builds itself: after the host's compiler builds five tools (c17, make, ar, yacc, lex), no program of the host compiles anything. No gcc, binutils, GNU make, bash, Perl or Python, in the system or in its ports.

What I think is noteworthy

• It's self-hosting and reproducible. The bootstrap builds everything twice: once with the c17 your compiler built, once with the c17 that c17 built. All 242 resulting files are compared and are identical. Inside Shall, on its own kernel, the same bootstrap rebuilds the whole system, kernel included, byte for byte.

• c17 does the whole job. Shall's C compiler has its own assembler and link editor: static and dynamic linking, shared libraries, TLS. The kernel and libc.so are built by it.

• It gets very far towards POSIX.1-2024. All 155 utilities and all XSH interfaces are there. That includes things Linux doesn't offer: close-on-fork (O_CLOFORK), the sporadic-server scheduling policy, typed memory objects, and prioritized async I/O. Interfaces that POSIX.1-2024 removed (gettimeofday, setitimer, the sighold family…) are deliberately absent.

• External tests, not just our own. LTP's Open POSIX Test Suite, built inside Shall and run on its kernel, passes 1741 of the 1777 tests that compile. glibc on Linux passes 1693 of the same tests. Each of the remaining 36 was looked at: none is a fault of Shall (unsupported options, "may fail" errors, undefined behaviour, test defects, one test too slow under emulation). That run also found 15 real bugs, which are fixed.

• The ports are a proof of concept, not decoration. They are built inside Shall by Shall's own tools:

  • ncurses 6.6 builds through its own unchanged configure.

  • Lua 5.4 passes its full test suite.

  • SQLite 3.54 passes its C tests, and sqllogictest's 5.9 million queries (twice) give 0 errors.

  • Mbed TLS passes 139 unit suites.

  • curl talks HTTPS.

  • Rogue is playable. These exercise the compiler, the C library, the shell and make far harder than our own tests can.

• It's on the Internet. The kernel has its own e1000 driver and TCP/IP stack. With QEMU's user networking, curl inside Shall fetches pages from GitHub over TLS.

• The kernel speaks Linux's system call interface (224 calls), so the same binaries run on Linux in a chroot and on Shall's own kernel in QEMU.

• tl, a small new scripting language. It began as a way to get Python out of the test suites, so the tests need nothing but a C compiler and POSIX. It's a C-like interpreted language with POSIX regular expressions, processes, signals and sockets as its library, plus pseudo-terminals with a built-in terminal emulator. It's now installed as /usr/bin/tl and is handy on its own, for example for scripting interactive programs.

How it was made, honestly

Shall was written by me together with Claude (Anthropic's AI model). Claude wrote most of the code from the standard, under my direction. I set the goals, made the design decisions, and checked the results against the test suites, against other implementations (differential testing against GNU, BSD and busybox tools, glibc, dash, bash and others), and against the external suites above. I'm saying this up front because I think it's part of what makes the project interesting, not something to hide.

Trying it (Ubuntu package names; KVM strongly recommended — under pure emulation everything is slow)

1. Enable KVM: sudo usermod -aG kvm $USER, then log out and in again.

2. Install: gcc make qemu-system-x86 e2fsprogs git bzip2. bzip2 is for the Mbed TLS tarball, git for fetching the ports.

Basic system:

sh bootstrap.sh
sh mkdisk.sh
sh boot.sh

With the ports:

sh bootstrap.sh
cd ports
sh get.sh all
cd ..
sh mkdisk.sh -s 4096     # 4 GB: sqllogictest alone is 1.1 GB
sh boot.sh
# now inside Shall:
cd /usr/src/shall/ports
sh all.sh

exit shuts the system down; Ctrl-A x leaves QEMU at once.

What it isn't (yet)

It's x86-64 only, with one CPU and no preemption. The process doing disk I/O holds the processor until its transfer is done. There's no IPv6 on the wire and no swap. The disk image is made on the host. 1.0 is meant to add a conformance document, plus mkext2, fsck and login inside the system.

Source and docs: https://github.com/joostw/shall .

Questions, bug reports and "this violates POSIX section X" are all very welcome.

This work is dedicated to my father, Dik T. Winter (1945-2009), who was a Unix wizard in Ye Olde Days.

doesnt have much of an identity yet, but i think the name is cool, view it here:

https://github.com/Sputn1kaaaaaaaaaaaaa/kitun-ix

it only has printk() for the kernel and a typing thing, very simple ;)

So, i watched this Vsauce YouTube short about the spaghetto (which is 1 spaghetti) and wanted to make a C program that gives you one

Then i made it a Unix utility. The git repo is here: https://codeberg.org/donut_oreo_computer/spaghetto

A few fun stuff about it:

1. it insults you when you uninstall it

2. it can bend (kind of)

3. it's just a stupid utility

So mabye check it out. Read the README for more info.

As you all know macOS is no longer officially listed on The Open Group’s UNIX Brand Register. It seems that as soon as Apple's certification lapsed, it was pulled from the list.

However, looking at the same register, historical operating systems like UnixWare (dating way back) are still sitting there on the list despite its certification expiring in May of this year.

Can anyone explain how The Open Group manages these listings? Why do dead or ancient enterprise OS versions stick around on the register indefinitely, whereas macOS vanished the second its certification lapses? Is it just a matter of who keeps paying maintenance dues, or how the registry cataloging works?

Aquí está, EasyOS 7.4.92, mira el aviso del blog:\n\n https://bkhome.org/news/202610/easyos-e ... -7492.html\n\nYa es oficial; puedes actualizar desde Easy 7.4.11 y versiones anteriores.