LAL OS: Building an Independent Operating System with Delphi / Object Pascal
LAL OS is an independent x86 operating system project being developed in Türkiye.
It is not a Linux distribution, not a Windows shell, and not a desktop environment running on top of another operating system.
The project is being built as a complete operating-system stack, from the boot process and kernel to storage, networking, TUI, graphics, GUI architecture and application/runtime layers.
One of the most unusual aspects of the project is the technology behind it:
a significant part of LAL OS is being developed with Delphi / Object Pascal.
For many developers, Delphi is associated primarily with desktop applications, enterprise software and database systems.
With LAL OS, we are exploring how far Object Pascal can be pushed into low-level systems engineering.
From Boot to Desktop
The architecture is being developed around our own system chain:
Firmware / Disk
↓
LAL Bootloader
↓
LAL Kernel
↓
System Services
↓
TUI / Shell
↓
Graphics / GUI / Applications
The goal is to keep the fundamental operating-system layers under our own architectural control rather than building the system around an existing Linux or Windows runtime.
LAL OS currently targets the x86 platform, while the architecture continues to evolve toward broader hardware and multicore support.
Kernel Development
The kernel side includes work around:
- memory management
- tasking and scheduling
- interrupt and exception handling
- kernel/user execution boundaries
- system APIs
- process infrastructure
- device discovery
- disk and hardware services
We are also actively working on SMP and multicore architecture.
The objective is not merely to enumerate CPU cores. The scheduler, tasking model, interrupts and system services must progressively become multicore-aware.
LALFS and Disk Management
LAL OS is not intended to remain a RAM-only demonstration system.
Storage is part of the operating-system architecture.
We are developing our own disk management infrastructure together with LALFS — LAL File System.
The TUI/Shell layer already provides system-oriented commands for filesystem and disk operations, including operations such as directory management, disk formatting and system control.
The larger objective is to expose storage functionality through LAL OS system services rather than implementing storage logic separately inside applications.
TUI and Command Infrastructure
The graphical environment is not the only interface to the system.
LAL OS also has its own TUI / Shell layer.
This environment is intended to remain usable independently from the graphical desktop and provides access to areas such as:
- filesystem operations
- disk management
- system information
- date and time
- device information
- reboot
- shutdown
- system commands
This separation is important to us because the core operating system should not depend on the desktop being available.
Networking and SMTP
Networking is another independent system layer under development.
The networking architecture includes work around:
- network-device integration
- TCP/IP-oriented communication
- client connections
- system networking services
- data transport
- SMTP infrastructure
Rather than treating every network capability as application-specific code, the long-term goal is to expose reusable networking services through the operating system.
Graphics Decoders and Image Infrastructure
The graphics stack is more than a framebuffer.
LAL OS includes its own graphics/image decoding layers for handling visual assets such as:
- wallpapers
- icons
- application images
- UI resources
Keeping the decoder layer separate from the GUI framework allows additional image formats to be introduced without coupling them directly to the windowing system.
VBE / BGA as a Graphics Backend
LAL OS currently uses VBE/BGA as part of its graphics hardware abstraction.
For us, VBE is not the GUI architecture itself.
It is a backend responsible for areas such as:
- display mode
- resolution
- framebuffer
- pixel format
- video memory
- screen configuration
Above that backend sits the actual UI architecture.
Graphics Backend
↓
ZuzuGUI
↓
Scene
↓
Surface
↓
Compositor
↓
Presentation
The intention is to prevent the upper GUI system from becoming permanently coupled to one graphics backend.
ZuzuGUI and Mozaik
The graphical system is being developed around ZuzuGUI and the Mozaik desktop environment.
Instead of treating the desktop as only:
window
↓
bitmap
↓
z-order
↓
framebuffer
we are separating responsibilities into dedicated architectural authorities:
- Window Lifecycle
- Scene Authority
- Surface Ownership
- Compositor Authority
- Retained View Tree
- Input / Focus Authority
- Presentation
This separation is one of the most important architectural areas of the project.
Window lifetime, rendering ownership, input routing, composition and final presentation should not all be controlled by one monolithic manager.
Hardware Work
Modern hardware support is another major workstream.
Current development areas include:
- PCI / PCIe
- xHCI
- USB
- AHCI
- NVMe
- keyboard and mouse
- storage controllers
- device discovery
QEMU and VMware are currently useful for rapid development and testing, while bare-metal hardware support continues to mature.
PE / EXE Compatibility
We are also developing an incremental PE/EXE execution infrastructure.
The goal is not to claim complete Windows compatibility.
The compatibility layer grows together with the operating system's own:
- process model
- loader
- memory services
- exception handling
- threading
- runtime services
This is intended as a gradual compatibility path rather than a promise of full Win32/NT compatibility.
OpenJDK Integration
OpenJDK integration is another area being prepared.
At the current stage, this work focuses on runtime layout, binaries, modules and the surrounding execution requirements.
OpenJDK is not part of the LAL OS kernel.
It is being treated as an external user-space runtime that may eventually execute on top of LAL OS as the required process, memory, threading and loader services mature.
Development Ecosystem
Our longer-term goal is to make LAL OS a platform on which developers can build software using multiple languages and toolchains.
The roadmap includes:
- Delphi / Object Pascal
- Free Pascal
- Lazarus
- C
- C++
- Java / OpenJDK
We are also developing our own programming-language project called Motif.
Motif is not intended merely to introduce another syntax.
The long-term objective is to create a language and execution model capable of expressing LAL OS architecture, system contracts, GUI/runtime services, and future AI-assisted development models more naturally.
Why Object Pascal?
This is one of the questions we expect most often.
The answer is simple:
Because a programming language should be judged by what can actually be engineered with it.
Operating-system development exposes a language and its toolchain to some of the hardest software-engineering problems:
- memory ownership
- ABI boundaries
- executable formats
- hardware access
- interrupt handling
- concurrency
- scheduling
- drivers
- graphics
- runtime design
LAL OS is our attempt to explore those boundaries with Object Pascal in a real system rather than through theoretical arguments.
Where the Project Is Today
LAL OS is still under active development.
There is a long road ahead in areas such as:
- hardware compatibility
- SMP maturity
- networking
- drivers
- runtime support
- application compatibility
- developer tooling
But the system is growing layer by layer.
Our goal is not to create another distribution.
Our goal is to build an independent operating-system technology stack whose major architectural layers we understand and control ourselves.
From bootloader to kernel.
From disk to network.
From TUI to GUI.
From graphics backend to compositor.
From runtime infrastructure to future programming-language support.
That is what LAL OS is about.
LAL OS
Independent operating-system development from Türkiye.
Suggested DEV.to tags:
osdev,
operatingsystem,
programming,
delphi
Top comments (0)