HN comparte: un OS de hobby escrito desde cero por fin corre en una IBM ThinkPad vintage

 (github.com/joexbayer)
4 puntos por GN⁺ 2025-04-27 | 1 comentarios | Compartir por WhatsApp
  • RetrOS-32 es un sistema operativo de hobby totalmente personalizado de 32 bits, creado alrededor de la arquitectura i386, e incluye gráficos, multitarea y red
  • El kernel, las utilidades y el sistema de compilación están escritos en C y Assembly, y las aplicaciones de espacio de usuario están escritas en C++; usa Make y Docker para la compilación
  • Entre el hardware real probado están Lenovo x240, la serie Asus Eee PC, Dell Optiplex 780, Samsung N150 Plus, Samsung NP-NC10 e IBM Thinkpad a21p
  • Soporta ejecución en QEMU, v86 de copy.sh y arranque en hardware real; en dispositivos físicos usa una GRUB ISO para grabar el archivo .iso en USB o CD y ejecutarlo
  • En la hoja de ruta aparecen como elementos ya implementados el bootloader, la planificación preventiva multihilo, el sistema de archivos, el gestor gráfico de ventanas, la pila de red, los hilos en espacio de usuario y una terminal virtual remota TCP

Resumen de RetrOS-32

  • RetrOS-32 es un proyecto de sistema operativo de hobby de 32 bits enfocado en la arquitectura i386
  • La descripción del proyecto indica que es un sistema operativo de hobby de 32 bits con gráficos, multitarea y red
  • La fecha de inicio figura como 12 de mayo de 2022
  • La página del proyecto enlaza a Project OSHub page

Inicio de sesión y usuarios

  • Los usuarios predeterminados son system, admin y guest
  • La contraseña de admin es admin, y guest no tiene contraseña
  • Actualmente no hay diferencia entre admin y guest
  • Los usuarios pueden crearse con el comando admin create <username> <password>

Lenguajes de implementación y configuración de compilación

  • El kernel, las utilidades y el sistema de compilación están escritos en C y Assembly
  • Las aplicaciones de espacio de usuario están escritas en C++
  • Para compilar se usa Make
  • Para compilación multiplataforma se usa Docker

Hardware probado

  • La lista de hardware real probado es la siguiente
    • Lenovo x240
    • Asus Eee PC series
    • Dell Optiplex 780
    • Samsung N150 Plus
    • Samsung NP-NC10
    • IBM Thinkpad a21p

Cómo compilar y ejecutar

  • En un entorno multiplataforma, para compilar el archivo de imagen se necesita Docker, y para la emulación se necesita QEMU
  • Las dependencias de compilación nativa varían según la plataforma
    • MacOS: i386-elf-gcc, i386-elf-ld, i386-elf-g++
    • Linux / WSL Ubuntu: build-essential, gcc-multilib
    • Si se usa GRUB como bootloader, también se requieren grub2, xorriso y xxd
  • En Linux, la compilación y ejecución siguen este orden: clonar el repositorio, ./debian.sh, inicializar los submódulos de Git, make compile, make img, make qemu
  • En MacOS, la compilación nativa no es posible actualmente porque las herramientas de build dependen de código x86 de 32 bits, así que Docker es la forma más simple
  • En Windows se usa Docker o WSL
  • Hay tres formas de ejecución
    • Subir el archivo .img como imagen de disco duro en copy.sh v86
    • Ejecutar make qemu o qemu-system-i386 <image name> en QEMU
    • Grabar el archivo .iso en un USB o CD y usar GRUB ISO en hardware real

Estructura del proyecto

  • La estructura del repositorio se divide en directorios de kernel, drivers, gráficos, red, sistema de archivos, bibliotecas, apps de espacio de usuario, pruebas y herramientas
  • boot contiene un bootloader personalizado y multiboot.ld
  • kernel contiene el código fuente principal del kernel, código específico por arquitectura y código de hilos del kernel
  • apps contiene aplicaciones de espacio de usuario y libcore.a, libgraphic.a, libnet.a
  • net contiene código de red y fs contiene código relacionado con el sistema de archivos
  • tools incluye herramientas y scripts de compilación

Elementos completados y trabajo pendiente

  • En los elementos relacionados con el arranque ya están completos el bootloader personalizado, la compatibilidad con GRUB y el bootloader Stage 2
  • Las funciones del kernel y del sistema incluyen lo siguiente
    • Planificación preventiva multihilo
    • Separación entre kernel y espacio de usuario basada en GDT y TSS
    • Manejo de interrupciones
    • IPC
    • System calls
    • Hilos en espacio de usuario
  • Las funciones de drivers y hardware incluyen teclado y mouse PS/2, PIT, VESA 640x480x8, RTC, Serial, E1000 y PCI
  • En sistema de archivos y almacenamiento ya están completos el driver ATA IDE, un sistema de archivos similar a Ext2, FAT16 y lectura/escritura
    • FAT16 soporta archivos de hasta 32MB
    • Atapi sigue incompleto
  • Las funciones de memoria incluyen memoria virtual de 32 bits, kalloc/kfree del kernel y malloc/free del espacio de usuario
  • Las funciones gráficas incluyen gestor de ventanas, GFXLib, renderizado con doble framebuffer, eventos de mouse, redimensionado dinámico, pantalla completa y biblioteca de widgets
    • Custom HTML to Widgets está incompleto
  • En la pila de red ya están completos Ethernet, IP, ARP, UDP, Socket API, interfaz loopback, DHCP, DNS, TCP y un comando estilo netcat
    • Webserver, FTP, IRC, SSH, Telnet, HTTP y HTML están incompletos
  • Entre las aplicaciones y herramientas están terminal, servidor de ventanas, información de procesos, Finder, compilador de C / intérprete de bytecode, una VM personalizada para ejecutar bytecode, editor con resaltado de sintaxis, calculadora, juego 3D, juego Snake en modo texto, terminal virtual remota TCP y biblioteca de compresión LZ
  • La lista completa de funciones propuestas y problemas conocidos está en open issues

Licencia y enlace del proyecto

Lecturas relacionadas

1 comentarios

 
GN⁺ 2025-04-27
Comentarios de Hacker News

  • Este tipo de proyectos se ven mucho mejor que la IA aburrida. Quizá no sea algo vendible, pero es una muestra de cómo una persona técnica despliega su creatividad
    Estudié mucho desarrollo de sistemas operativos como hobby a finales de mi adolescencia y me parecía increíble; incluso ahora, de vez en cuando hago kernels pequeños. El último que hice fue un pequeño kernel RISC-V que mostraba un mensaje para mi pareja

    • Es realmente liberador no tener que preocuparse por venderlo o hacer marketing. Puedes reinventar la rueda hasta que llegue una idea nueva
    • Suena raro llamar a la IA en bloque “aburrida”. Antes de envolverla en una experiencia de usuario inteligente, era una exploración académica que casi no daba dinero, o sea, algo más cercano a un trabajo artesanal
    • Suena como decir que un dispositivo hobby pequeño es mucho más interesante que la tecnología más absurda de la historia humana

  • Me gustaría que la tipografía base del sistema fuera una variante más estrecha. Creo que así el sistema se vería mucho más refinado, y en varias partes se nota que las letras necesitan más espacio horizontal
    Habría que reducir el ancho de cada carácter y también ajustar al mínimo el espacio entre letras. Con el tamaño y la resolución actuales de la fuente, 1 píxel de separación parece suficiente
    No sé mucho de sistemas de tipografías, pero asumí que es una fuente bitmap monoespaciada. Si en el código es muy difícil de cambiar, tampoco pasa nada
    Yo también llevo un tiempo haciendo desde cero un sitio de web OS, y hace poco reescribí toda la clase de fuentes, así que esto me llamó especialmente la atención

    • Coincido en que la fuente actual está lejos de ser óptima. Casi sigo usando tal cual la fuente inicial que hice funcionar al principio
      Ya revisé el renderizado tipográfico como corresponde y está en mi lista de pendientes, pero lo he ido postergando
    • Qué ambiente tan pesado
      “¡Hice un sistema operativo!”
      “Mmm, la tipografía no está tan buena”
      Esto parece el pico de HN

  • Está genial. Me da curiosidad saber qué harías distinto si volvieras a empezar hoy
    También me interesa qué lenguaje te parece adecuado para las partes de bajo nivel. Si seguirías con C, usarías un subconjunto simple de C++, o considerarías un lenguaje más nuevo
    Hay tantísimo material que también me da curiosidad cómo mantuviste el proyecto interesante sin copiar código ajeno

    • Lo principal que haría distinto sería planearlo. Al principio solo tenía el objetivo de hacer un hello world OS básico, pero fui agregando funciones nuevas y trabajando en varias cosas a la vez, y eso me dejó una deuda técnica que sigo pagando hasta hoy
      También creo que habría intentado reducir la dependencia de UNIX
      En cuanto al lenguaje, me gusta C por su sintaxis básica y por ir directo al grano. Para aplicaciones de espacio de usuario sí podría considerar otros lenguajes
      Quería escribir todo yo mismo desde el principio, y no portar software era parte central del proyecto. En general seguí la regla de “copia ideas, no código”

  • Es realmente genial, incluso visto por alguien que usó una Commodore PET 2001 en 1977. Había estado probando KolibriOS y MenuetOSx64, y esto me dio ganas de intentar hacer mi propio sistema operativo. Impresiona que lo hayas logrado

  • El proyecto es realmente impresionante y quería felicitarte. Desde adolescente me ha gustado el desarrollo de sistemas operativos, así que da gusto ver un logro así hecho realidad
    También me da un poco de curiosidad cómo se inicializa el subsistema gráfico. Ojalá te vaya muy bien

  • Ojalá yo también pudiera sacar tiempo para este tipo de proyectos de pasión
    Olvidarte de la utilidad práctica, olvidarte de la estrategia de entrada al mercado, olvidarte del ajuste con el mercado objetivo, y simplemente construir y aprender

    • De verdad se siente muy refrescante no tener que pensar si realmente “se va a usar” ni en el mercado. Es trabajo hecho puramente por diversión y aprendizaje
    • Me da curiosidad por qué no puedes sacar tiempo. Siento que, desde chico, sin proyectos hobby me habría sentido bastante perdido
      Uno de ellos era un OS de juguete, pero cuando el desarrollo de OS de bajo nivel se volvió mi trabajo real, ese proyecto se detuvo

  • Llevo décadas en este campo y estoy tratando de aprender desarrollo de OS. Conozco más o menos FASM, NASM y FASM-G
    Pero quiero estudiar la salida de programas ensamblador para entender cómo funciona realmente un OS a nivel binario
    Me da curiosidad si aprendiste los códigos de instrucción de alguna arquitectura específica, cómo hiciste los controladores de dispositivos y si podrías resumir las etapas de desarrollar un OS por tu cuenta

    • Creo que el mejor lugar para aprender es el foro de osdev y la wiki de osdev. Hay muchísimo material útil para empezar
      También hay algunos tutoriales, pero muchas veces tienen errores y es fácil terminar básicamente rehaciendo el OS de ellos
      No profundicé tanto en los códigos de instrucción; solo los revisé cuando hice el compilador de C, así que únicamente conozco las instrucciones básicas más comunes
      https://forum.osdev.org/
      https://wiki.osdev.org/Expanded_Main_Page

  • Está buenísimo. Ojalá volviera más ese espíritu de la computación temprana en el que la gente trasteaba más con la computadora misma que con el nivel de las aplicaciones
    Desde hace tiempo he pensado en hacer una computadora personal como proyecto hobby de largo plazo. Una computadora donde yo mismo construya toda la pila de software y pueda saber de dónde viene cada bit que entra al sistema
    El hardware sería más difícil de controlar al mismo nivel, a menos que con FPGA se pudiera lograr suficiente rendimiento para correr todo ahí, pero al menos el software sí parece posible
    Hasta ahora me parecía poco realista, pero esto muestra que sí se puede. Parece que también estás implementando un compilador de C hobby: https://github.com/joexbayer/C-Compiler

    • Saber que escribiste todo tú mismo, desde la parte alta del espacio de usuario hasta los drivers, se siente muy bien. Al mismo tiempo, también es un infierno de depuración
      El compilador de C lo hice para este OS y corre dentro del mismo OS. El proyecto se volvió demasiado grande, así que quise separarlo del repositorio del OS, sobre todo porque también funciona en Linux

  • Estaría bueno que explicaras un poco más cómo interactúa este compilador con el sistema operativo. En particular, me da curiosidad cómo manejas funciones como las structs, cuáles son las limitaciones actuales de esa área y qué mejoras tienes previstas

    • No hay ninguna interacción mágica entre el compilador y el OS. Simplemente compila al mismo código máquina (i386) y usa interrupciones para las llamadas al sistema
      Las structs se tratan como regiones de memoria cuyo tamaño se determina según sus miembros, y el acceso a los miembros se maneja como offsets dentro de esa región
      Por ahora tiene muchas limitaciones, como que solo existen int y char y ni siquiera hay sentencia switch. La mayor diferencia frente a C estándar es que se permiten funciones dentro de structs, y que si es una función de struct, la struct se pasa implícitamente a la función. Más detalles aquí:
      https://github.com/joexbayer/C-Compiler

  • Es uno de los proyectos de pasión más impresionantes que he visto aquí en bastante tiempo. Me da curiosidad por qué decidiste usar un compilador de C hecho por ti mismo

    • Tenía la regla de querer escribir todo por mi cuenta, y hacer un compilador siempre había sido una de mis “metas”. Así que encajó de forma natural